Pag-optimize ng Code sa Mga Microcontroller

Nilalaman

• Paano Sukatin ang Oras ng Pagpapatupad ng Code sa Eksperimento
• 1. Alamin ang Lakas ng Pagproseso at Laki ng memorya ng iyong Microcontroller
• 2. Pagpipili ng Mga variable para sa Pag-optimize sa Laki ng Code
• 3. Pagpili ng Mga variable para sa Pag-optimize sa Oras ng Pagpapatupad ng Code
• 4. Pag-optimize ng Mga Operasyon ng Arithmetic
• 5. Gumamit ng isang DSP Capable Microcontroller para sa Intensive Calculations
• Ang mga tagubilin sa isang DSP processor ay maaaring magsagawa nang mas mabilis pagkatapos ng isang ALU ay:
• Ang paggamit ng DSP engine ng isang microcontroller ay nangangailangan na:
• 6. Makipagtulungan sa Mga Nakagambala
• 7. Gumamit ng Pinakamahusay na Magagamit na Mga Compiler
• 8. Matalino na Gumagamit ng Mga Pahiwatig na Pahayag
• 9. Gumamit ng Mga Inline Function
• 10. Gumamit ng Mga Naidagdag na Loops
• Pagbabalot

Nakumpleto ng may-akda ang kanyang huling proyekto sa proyekto sa engineering sa dsPic micro-Controller, na nakakakuha ng malawak na pananaw sa mga aparatong ito.

Ang C-code ng isang microcontroller ay maaaring mangailangan ng pag-optimize sa ilang mga advanced na application. Isinasagawa ang pag-optimize ng code na ito upang mabawasan ang dalawang mahahalagang bagay:

1. Laki ng code: Maaaring mag-imbak ang mga Microcontroller ng limitadong data at mga tagubilin dahil sa limitadong laki ng kanilang RAM. Samakatuwid ang code ay kailangang ma-optimize, upang ang magagamit na tagubilin at memorya ng data ay maaaring magamit sa pinaka mahusay na paraan.
2. Mga Oras ng Pagpapatupad ng Code: Ang mga Microcontroller ay sunud-sunod na aparato na nagsasagawa ng isang tagubilin nang paisa-isa. Ang bawat tagubilin sa pagpupulong ay kumokonsumo ng isang tiyak na bilang ng mga cycle ng orasan upang maisagawa ang sarili nito. Samakatuwid ang code ay dapat na na-optimize upang matiyak na ito ay gumaganap ng kinakailangang gawain ng hindi bababa sa bilang ng mga cycle ng orasan o mga tagubilin sa pagpupulong. Ang mas kaunting orasan na ginagamit ng isang code, mas mabilis itong tumatakbo. Nangangahulugan ito na ang mga application ay maaaring tumakbo nang mas mabilis dahil ang oras ng pagpoproseso ay nai-minimize.

Ipinapakita ng artikulong ito ang mga tip at trick na maaaring gamitin upang mabawasan ang laki at oras ng pagpapatupad ng isang micro-controller code.

Ang MplabX development IDE ng Microchip ay gagamitin upang maipakita ang mga halimbawa kung naaangkop.

Paano Sukatin ang Oras ng Pagpapatupad ng Code sa Eksperimento

Upang makakuha ng ideya kung gaano karaming oras ang aktwal na ginugugol ng iyong code upang maisagawa sa real-time, kailangan mong sukatin ito nang eksperimento. Ang isang tagapag-aral ng lohika ay maaaring maginhawang magamit upang masukat ang oras ng pagpapatupad ng code at ang mga interesado ay maaaring magtanong tungkol sa proseso para sa akin mula sa email. Sa tabi nito:

• Ang ilang mga tagataguyod ay may kakayahang bilangin ang mga pag-ikot ng orasan na isang code ay ubusin.
• Ang ilang mga debugger halimbawa ang ICD 3 mula sa microchip ay maaaring direktang masukat ang oras ng pagpapatupad sa pamamagitan ng isang stopwatch.

1. Alamin ang Lakas ng Pagproseso at Laki ng memorya ng iyong Microcontroller

Hindi palaging ang dalas ng orasan (Mhz) na nagbibigay ng totoong larawan ng bilis ng pagproseso ng isang micro-controller, isang mas makatotohanang panukala ay MIPS (mga tagubilin sa mega bawat segundo) o ang bilang ng mga tagubiling maaaring maisagawa ng MCU sa isang segundo.

Karaniwang saklaw ang mga MCU mula 60-70 MIPS sa kategorya ng high-end hanggang 20 MIPS 8-bit AVRs. Ang isang mataas na MIPS micro-controller ay malamang na maging mas mahal pagkatapos ng isang low-end na aparato kaya dito mayroon kang trade-off sa pagitan ng gastos at bilis ng pagproseso.

Ang mga Micro-Controller ay may magkakahiwalay na memorya para sa pagtatago ng data at code ng programa. Ang laki ng pareho sa kanila ay maaaring matagpuan mula sa datasheet. Maaaring kailanganin mo ang isang MCU na may mas malaking sukat ng memorya kung ang iyong code ay malaki ang laki.

2. Pagpipili ng Mga variable para sa Pag-optimize sa Laki ng Code

Ang mga Micro-Controller ay may limitadong memorya ng data, karaniwang mula 1 hanggang 4 Kbytes. Sa kasong ito matalino na pumili ng pinakaangkop na uri ng variable ayon sa inaasahang saklaw ng petsa na naimbak. Ang talahanayan sa ibaba ay nagbubuod ng mga variable na ito:

Buod ng mga variable na ginamit sa wikang C-wika.

Uri ng variable	Laki sa Bytes	Saklaw
bool	1	0 o 1 lang
char	1	-128 hanggang 127
int	2	-32,768 hanggang 32,767
unsigned int	2	0 hanggang 65,535
mahaba	4	-2,147,483,648 hanggang 2,147,483,647
lumutang	4	Tiyak na hanggang 6 na decimal na lugar
doble	8	Tiyak na hanggang sa 15 decimal na lugar
mahabang doble	10	Tiyak na hanggang sa 19 decimal na lugar

Halimbawa:

• Kung ang dalawang variable na X at Y ay maidaragdag at ang resulta ay itatabi sa Z ngunit ang halaga ng Z ay inaasahang mas mataas pagkatapos ay 65,535 pagkatapos ng pagdaragdag pagkatapos ay ang Z ay maaaring ideklara bilang isang mahaba at ang X at Y ay maaaring ideklarang hindi pirmado Int, ang mga halaga ng X at Y ay hindi rin inaasahan na maging negatibo. Makakatipid ito ng 04 bytes sa memorya ng data na maaaring hindi nagamit kung ang lahat ng mga variable ay maaaring ideklara hangga't.
• Dalawang variable na X at Y, na ang mga halaga ay inaasahang nasa buong bilang ay hahatiin, ngunit ang resulta ng paghati ay maaaring magbunga ng isang decimal, pagkatapos ang X at Y ay maaaring ideklara int at ang resulta ay maaaring ideklarang isang float o doble depende sa ang eksaktong kinakailangan.

Ang pagpili ng uri ng data ay maaaring maging mahalaga kapag idineklara ang mga arrays na naglalaman ng maraming bilang ng mga elemento.

3. Pagpili ng Mga variable para sa Pag-optimize sa Oras ng Pagpapatupad ng Code

• Ito ay isang naitaguyod na katotohanan na ang mga kalkulasyon na lumulutang-point ay tumatagal ng mas mahaba kaysa sa mga kalkulasyong nakapirming-point. Huwag gumamit ng variable na lumulutang-point kung saan hindi kinakailangan ang isang decimal na halaga. Makipagtulungan sa mga hindi naka-sign na integer saanman posible.
• Mas gusto ang mga lokal na variable kaysa sa mga pandaigdigang variable. Kung ang isang variable ay ginagamit lamang sa isang pagpapaandar dapat itong ideklara sa pagpapaandar na iyon sapagkat ang pag-access sa mga pandaigdigang variable ay mas mabagal kaysa sa mga lokal na variable.
• Ang isang 8-bit MCU ay makakahanap ng isang solong byte-size variable na mas mabilis upang ma-access at ang isang 16-bit MCU ay makakahanap ng isang 2-byte variable na mas madaling ma-access dahil sa haba ng nabuong address.

4. Pag-optimize ng Mga Operasyon ng Arithmetic

Ang mga pagpapatakbo ng aritmetika ay maaaring ma-optimize sa mga sumusunod na paraan.

1. Gumamit ng mga talahanayan ng paghahanap ng mga paunang nakalkulang halaga sa halip na suriin ang isang Sine o anumang iba pang pagpapaandar na trigonometric o anumang iba pang operasyon na ang resulta ay maaaring malaman muna sa code.
2. Kung sakaling ang isang sine look-up na mesa ay nakaimbak na sa memorya ng isang cosine ay maaaring masuri sa pamamagitan ng pagsulong ng array pointer na katumbas ng 90 degree.
3. Kabilang sa apat na pagpapatakbo ng aritmetika, ang paghahati at pagpaparami ay tumatagal ng pinakamaraming oras sa pagproseso, sa pagsasagawa ay maaaring nasa saklaw ng daan-daang mga micro-segundo o higit pa kung sakaling may lumutang na mga halaga.
4. Gumamit ng mga tagubilin sa paglipat ng bit sa halip na paghahati at pagpaparami. Ang isang tamang tagubilin sa paglilipat 3 ay nagsisilbi upang hatiin sa 2³ kung saan bilang isang kaliwang tagubilin sa paglilipat 1 ay magsisilbi upang dumami ng 2¹.

5. Gumamit ng isang DSP Capable Microcontroller para sa Intensive Calculations

Ang ilang mga micro-Controller ay may isang unit ng pagpoproseso ng DSP iba ​​pa pagkatapos ng maginoo na ALU na nakapaloob sa kanilang arkitektura. Ang DSP engine na ito ay nakatuon upang maisagawa ang mga kalkulasyon ng arithmetic nang napakabilis sa hindi bababa sa bilang ng mga cycle ng orasan (isa sa karamihan ng mga kaso) nang maraming beses nang mas mabilis pagkatapos ng ALU.

Ang mga tagubilin sa isang DSP processor ay maaaring magsagawa nang mas mabilis pagkatapos ng isang ALU ay:

• Bit shift at paikutin ang mga tagubilin.
• Pagpaparami, Dibisyon at iba pang mga pagpapatakbo ng arithmetic.
• Sinusuri ang Mga Sine at iba pang mga pag-andar ng trigonometric.
• Lahat ng pagpapatakbo ng DSP tulad ng FFT, DFT, convolution at pagsala ng FIR.

Ang paggamit ng DSP engine ng isang microcontroller ay nangangailangan na:

• Ang magkakahiwalay na mga aklatan ng DSP ay isinasama sa proyekto.
• Ang mga pangalan ng pag-andar ay naiiba mula sa pamantayang aklatan ng matematika ng C-wika. Ang dokumentasyon ng mga aklatan at pag-andar na ito ay maaaring magamit mula sa kani-kanilang website ng mga tagagawa.
• Gumagamit ang DSP engine ng iba't ibang uri ng variable na 'praksyonal'. Alamin kung paano gumamit ng mga variable na uri ng praksyonal bago magpatuloy sa mga pag-andar ng library ng dsp.

Tandaan na ang karaniwang pag-andar ng library ng matematika ay hindi mag-iimbita ng DSP engine dahil naisalin sila sa mga tagubilin sa pagpupulong ng ALU.

6. Makipagtulungan sa Mga Nakagambala

Gumamit ng mga nakakagambala para sa pagganap ng mga partikular na pag-andar tulad ng:

• Pagbasa ng mga halagang ADC.
• Nagpapadala at tumatanggap mula sa UART.
• Ina-update ang mga rehistro ng cycle ng tungkulin ng PWM.
• CAN o I2C na komunikasyon.

Ang mga nakakagambala ay maglilingkod sa mga pagpapaandar na ito nang mabilis kumpara sa pagganap ng mga ito sa pangunahing katawan sa pamamagitan ng isang function na tawag o inline code.

Ang mga pagkagambala ay magti-trigger lamang kapag kinakailangan, samantalang kung naka-code sa pangunahing katawan, ang code ay isasagawa sa bawat pag-ulit ng habang (1) loop.

7. Gumamit ng Pinakamahusay na Magagamit na Mga Compiler

Maaaring awtomatikong ipatupad ng mga tagataguyod ang ilan sa mga pag-optimize na tinalakay sa itaas habang isinalin ang code mula sa C-wika sa wika ng pagpupulong kung maayos na na-configure. Maghanap para sa mga pagpipilian sa pag-optimize sa iyong tagatala at kung posible na mag-upgrade sa mga propesyonal na bersyon ng mga tagagsama dahil ang mga ito ay mas malakas na mga optimizer ng code.

8. Matalino na Gumagamit ng Mga Pahiwatig na Pahayag

• Kapag gumagamit ng isang serye ng mga kung-ibang pahayag panatilihin muna ang pinaka-maaaring kalagayan. Sa ganitong paraan hindi kakailanganin ng MCU na i-scan ang lahat ng mga kundisyon matapos itong makita ang totoong kondisyon.
• Ang isang pahayag na switch-case ay kadalasang mas mabilis ang isang kung-iba pa.
• Gumamit ng mga pugad na kung-ibang pahayag na kapalit ng isang serye ng mga pahayag. Ang isang if-else block na mayroong maraming mga pahayag ay maaaring nahahati sa mas maliit na mga sub-branch upang ma-optimize para sa pinakamasamang kalagayan ng kaso (huling).

9. Gumamit ng Mga Inline Function

Ang mga pagpapaandar na magagamit nang isang beses lamang sa code ay maaaring ideklarang static. Gagawa nitong i-optimize ng tagatala ang pagpapaandar na iyon sa isang naka-andar na pag-andar at sa gayon walang code ng pagpupulong ang naisasalin para sa tawag na pagpapaandar.

• Ang isang pagpapaandar ay maaaring ideklarang inline sa pamamagitan ng paggamit ng keyword na 'static' kasama nito.

10. Gumamit ng Mga Naidagdag na Loops

Ang isang decremented loop ay makakabuo ng mas kaunting code ng pagpupulong kumpara sa isang nadagdag na loop.

Iyon ay dahil sa isang increment loop, kinakailangan ng isang pagtuturo sa paghahambing upang ihambing ang loop index na may maximum na halaga sa bawat loop upang suriin kung naabot ng loop index ang maximum na halaga. Sa kabaligtaran sa isang decrement loop, ang paghahambing na ito ay hindi na kailangan dahil ang nabawasan na resulta ng loop index ay magtatakda ng zero flag sa SREG kung umabot sa zero.

Dahil sa ang loop ay dapat umulit ng daang beses, ang pagbawas ng isang tagubilin mula sa loop ay maiiwasan itong isagawa nang isang daang beses kaya't ang epekto ay malamang na maging mas makabuluhan kapag ang loop ay dapat umulit ng maraming beses.

Pagbabalot

Ang mga tip na ito ay maaaring maging kapaki-pakinabang ngunit ang kanilang totoong aplikasyon at potency ay nakasalalay sa kakayahan ng programmer at ng utos na mayroon siya sa kanyang code. Tandaan, ang laki ng programa ay hindi palaging tumutukoy sa mga oras ng pagpapatupad, ang ilang mga tagubilin ay maaaring ubusin ang mas maraming mga cycle ng orasan pagkatapos ng iba pa kaya't ang mga kasanayan sa programa ay dapat ding gampanan.

Ang artikulong ito ay tumpak at totoo sa abot ng kaalaman ng may-akda. Ang nilalaman ay para lamang sa mga layuning pang-impormasyon o aliwan at hindi kapalit ng pansariling payo o payo sa propesyonal sa mga usapin sa negosyo, pampinansyal, ligal, o panteknikal.