Hoe laag (vermogen) kun je gaan?

In mijn laatste bericht, "Arm Cortex-M low-power-modus-fundamentals", hebben we de fundamenten onderzocht van low-power-modi die te vinden zijn op elke Arm Cortex-M-processor en hoe we de WFI- en WFE-instructies kunnen gebruiken om een ​​processor te plaatsen slapen. De vraag die echter overblijft, is hoe deze modi met laag energieverbruik worden geïmplementeerd op een echte microcontroller en hoe die modi van invloed zijn op ons embedded systeem? In dit bericht zullen we in meer detail onderzoeken hoe we een microcontroller in de slaapstand kunnen zetten en zien hoeveel energie ons dat kost.

Experimenteren in modus met laag energieverbruik

De beste manier om energiebesparende modi te verkennen, is door een microcontroller te selecteren en de processor daadwerkelijk in verschillende energiebesparende modi te laten draaien. Voor dit bericht heb ik besloten om mijn beproefde NXP Kinetis-L Freedom-bord af te stoffen, waarmee ik niet alleen heb geëxperimenteerd, maar ook in veel producten, toepassingen en cursussen heb gebruikt. Ik besloot ook, goed of fout, om niet alleen de hoeveelheid energie te meten die de microcontroller aan het tekenen was, maar het hele ontwikkelbord. De MCU is meestal een van de meest energieverslindende apparaten op een bord, maar ik heb vaak gemerkt dat het meten van de volledige systeemstroom me eraan herinnert dat het niet de enige energieverbruiker op het bord is. Het optimaliseren van de microcontroller kan een lange weg gaan, maar het is niet altijd het enige apparaat dat mogelijk energie-optimalisatie vereist.

Begin met een nulmeting

Wanneer ik bezig ben met het optimaliseren van het energieverbruik van een product, begin ik eerst met een nulmeting van de energie. Dit wordt normaal gesproken gedaan door het huidige verbruik van het apparaat gedurende enkele seconden of minuten te profileren om te begrijpen waar we beginnen. Voor mijn experiment met het ontwikkelbord heb ik de Kinetis-L in de run-modus gelaten zonder slaapstand, alle randapparatuur aan en heb ik het bord ingesteld om periodiek een LED te schakelen. Met behulp van IAR Embedded Workbench met een I-Jet debugger en de I-Scope, kon ik een eenvoudige basislijn voor mijn bord profileren ~ 16,9 mA wanneer de LED uit was en ~ 18,0 mA wanneer de LED aan was, wat hieronder te zien is in Afbeelding 1. Zoals u kunt zien, is het belangrijk om te weten waar u uw meting vandaan haalt, anders kunt u er aanzienlijk naast zitten in uw analyse.

klik voor grotere afbeelding

Figuur 1. Een stroommeting van het ontwikkelbord met een LED die eenmaal per seconde omschakelt. (Bron:Auteur)

Energie optimaliseren met wacht- en diepe slaapstanden

De snelste manier om wat energiebesparingen te zien, is door de wacht- of diepe slaapmodus te implementeren. Een bestudering van de datasheet van de Kinetis-L-processors leert dat de wachtmodus bij 3 volt tussen de 3,7 en 5,0 mA trekt. In deze modus zijn de klokken van de CPU en randapparatuur uitgeschakeld, maar de flitser bevindt zich in een slaapmodus waardoor de processor nog steeds kan ontwaken binnen een onderbrekingstijdsbestek (12 – 15 klokcycli). De wachtmodus is eenvoudig te implementeren, de code om de wachtmodus te openen is hieronder te zien:

void Sleep_Wait(void)
{
      SCB_SCR &=~ SCB_SCR_SLEEPDEEP_MASK;
      asm(“WFI”);
}

Scroll of sleep de hoek van het vak naar breid indien nodig uit.

Met alleen die twee regels code daalt het stroomverbruik van het ontwikkelbord van 18,0 mA naar 15,9 mA. Dat is een daling van 11,6% van het stroomverbruik! Als het bord zou worden gevoed door een batterij van 680 mA, zou de levensduur van de batterij van het apparaat zijn gestegen van 37,8 uur naar 42,8 uur! Een toename van vijf uur van slechts twee regels code!

Het mooie van deze energiemodi op hoog niveau is dat we gemakkelijk nog een stap verder kunnen gaan. In plaats van de processor in de wachtmodus te zetten, kunnen we hem in een diepe slaap-wachtmodus zetten met de volgende code:

void Sleep_Deep(void)
{
      SCB_SCR |=SCB_SCR_SLEEPDEEP_MASK;
      asm(“WFI”);
}

Scroll of sleep de hoek van het vak naar breid indien nodig uit.

We hebben alleen maar een bit in het SCB_SCR-register aangepast en we zijn nu van een oorspronkelijke stroomafname van 18 mA naar 14,8 mA gegaan. Dat is een daling van 17,8% van het stroomverbruik! Nogmaals, ervan uitgaande dat het bord werd gevoed door een batterij van 680 mA, zou de levensduur van de batterij nu zijn gestegen van 37,8 uur naar 46 uur! Dit zijn enkele grote besparingen voor slechts een paar regels code en het is slechts het topje van de ijsberg!

Gebruikmaken van stop- en VLLS-modi voor uA-stroomafname

Het gebruik van de stopmodus heeft het potentieel om het stroomverbruik van de MCU met nog eens twee milliampère verder te verlagen door de kern- en systeemklokken uit te schakelen. Wat u zult vinden, is dat hoe lager de energiemodus, hoe meer code er nodig is om het te implementeren en hoe complexer de code wordt om het systeem weer wakker te maken. De code om naar de stopmodus op de Kinetis-L te gaan, vindt u hieronder:

void Sleep_Stop(void)
{
      vluchtige niet-ondertekende int dummyread =0;
      SMC_PMCTRL &=~ SMC_PMCTRL_STOPM_MASK;
      SMC_PMCTRL |=SMC_M_MCTRL
      dummyread =SMC_PMCTRL;
      Sleep_Deep();
}

Scroll of sleep de hoek van het vak naar breid indien nodig uit.

Merk op dat de stopmodus wordt bestuurd via een energiebeheercontroleregister en zodra de status is ingesteld, wordt de Sleep_Deep-functie aangeroepen om het instellen van de energiemodus en het uitvoeren van WFI te voltooien.

Tot nu toe hadden we het over de MCU-tekening 1 – 2 mA. Een moderne microcontroller heeft vermogensmodi die microampères of zelfs nanoampères kunnen trekken! De Kinetis-L-processor debuteerde rond 2013 en de Very Low Leakage Stop (VLLS) -modus trekt slechts 135 tot 496 microampère! De code om deze energiemodus te initialiseren is hieronder te zien:

void Sleep_VLLS1(void)
{
      vluchtige unsigned int dummyread =0;
      SMC_PMCTRL &=~ SMC_PMCTRL_STOPM_MASK;
      SMC_PMCTRL |=SMC_PMCTRL |=SMC_PMCTRL |=SMC_PMCTRL |=SMC_PMCTRL |=SMC_PMCTRL |=
      SMC_VLLSSTRL =SMC_VLLSCTRL_LLSM(1);
      dummyread =VLLS_CTRL;
      Sleep_Deep();
}

Scroll of sleep de hoek van het vak naar breid indien nodig uit.

Op dit punt zou de microcontroller bijna geen energie verbruiken!

Het effect van energiebesparende modi op de weklatentie

Zoals we tot nu toe hebben gezien, is het verplaatsen van de processor naar een lagere en lagere energiemodus een geweldige manier om energie te besparen, maar die besparingen brengen wel kosten met zich mee. Hoe lager de energiestatus van de processor, hoe meer tijd de processor nodig heeft om wakker te worden en nuttig werk te doen. Als ik bijvoorbeeld de standaard stopmodus zou gebruiken, zou het 2 ons plus de onderbrekingslatentie kosten voordat de processor wakker wordt en de code opnieuw begint uit te voeren. Niet slecht. Als ik echter een van de VLLS-modi op de Kinetis-L zou gebruiken, zou ik een wekvertraging hebben bij het opstarten van de processor plus nog eens 53 tot 115 microseconden! Dit is mogelijk niet acceptabel, afhankelijk van de toepassing. Afbeelding 2 toont extra overgangen van modi met laag energieverbruik naar de run-status op de Kinetis-L.

klik voor grotere afbeelding

Figuur 2. Overgangstijden van energiezuinige modi naar verschillende modi op de Kinetis-L. (Bron:Kinetis-L datasheet)

Conclusie

Arm-microcontrollers hebben allemaal de standaard energiezuinige modi, maar elke siliciumleverancier past de energiezuinige modi aan die beschikbaar zijn voor ontwikkelaars. Zoals we hebben gezien, bieden siliciumleveranciers vaak verschillende modi aan die fungeren als laaghangend fruit en die een minimaal effect hebben op de weklatentie. Ze bieden ook verschillende zeer energiezuinige modi die de processor bijna uitschakelen en slechts een paar honderd microampère of minder verbruiken! Ontwikkelaars moeten vaak een balans vinden tussen de hoeveelheid energie die ze willen gebruiken en hoe snel ze hun systeem nodig hebben om wakker te worden en te reageren op gebeurtenissen. De compromissen zijn absoluut toepassingsspecifiek, dus verwacht niet dat u op elk product en elke toepassing de laagste energiemodus kunt gebruiken.

Jacob Beningo is een embedded software consultant, adviseur en docent die momenteel samenwerkt met klanten in meer dan een dozijn landen om hun software, systemen en processen drastisch te transformeren. Neem gerust contact met hem op via [email protected], op zijn website www.beningo.com, en meld u aan voor zijn maandelijkse Embedded Bytes-nieuwsbrief.