Introduction aux MCU atTiny, partie 7

gestion de la consommation

Comme les micro-controlleurs sont souvent utilisés dans des gadgets fonctionnnant sur piles, les fabriquants tentent de réduire la consommation électrique au minimum. Les petits micro-controlleurs comme l'atTiny13a lorsqu'ils sont en mode power down consomment tellement peut qu'il n'est pas nécessaire de débrancher les piles. Dans cette chronique on va examiner les différentes méthodes pour réduire la consommation électrique.

Comme démo j'ai repris le jeux pong 1-D que j'ai réalisé sur un atTiny13a. voici le schéma:

Les LEDs sont montées en Charlieplexing sur PB0-PB3 et les boutons sont lus en ADC sur PB4. PB5 garde sa fonction de RESET.

Il s'agit d'une rangée de 8 LEDs et d'un bouton à chaque extrémitée. Une LED allumée qui circule d'une extrémitée à l'autre tiens lieu de balle que les joueurs se renvoient en pressant leur bouton respectif. Plus un joueur attend que la balle soit prêt de lui pour la renvoyer plus elle retourne rapidement réduisant d'autant les chances de l'adversaire de la frapper. La partie se termine lorsqu'on joueur a accumulé 15 points. Le pointage est affiché en binaire sur la rangée de LED. Les 4 LEDs de gauche indiquent le pointage du joueur de ce joueur et les autres celui de droite.

Économie d'énergie

code source tennis.c /* * NOM: tennis.c * DESCRIPTION: jeux linear pong. 8 LED en lignes. Une LED allumée * représante la balle et se déplace d'une extrémitée à l'autre. * À Chaque extrémité un joueur doit retourner la balle * à son adversare en pesant sur un bouton. * Il doit pesé sur son bouton avant que la balle dépasse * l'extrémitée. Mais il est préférable qu'il attende qu'elle * soit le plus près possible car la vitesse de retour * est inversement proprotionnelle à la distance qui la sépare * de lui. * Le premier joueur qui accumle 15 points gagne la partie. * * Au démarrage toutes les LED sont allumées pour débuter la * partie il faut qu'un des joueurs pèse sur son bouton. * Le choix du joueur qui a le service est aléatoire et est * indiqué par la LED qui clignote rapidement. * Il doit pesé sur son bouton pour lancer la balle. * L'autre joueur la retourne le plus tardivement possible. Le joueur * qui gagne l'échange acculume 1 point et prend le service. * * A la fin de la partie le pointage est indiqué en binaire * sur la rangée de LED. Le LED0 qui devrait-être à gauche * représente le bit de poids fort et le LED7 celui de poids * faible. Les LED 0-3 indique le pointage du joueur de droite * et les LED de 4-7 le pointage du joueur de gauche. Le pointage * reste affiché jusqu'à ce qu'un bouton soit enfoncé. Après quoi * une nouvelle partie peut débutée. * * AUTEUR : Jacques Deschênes * DATE : 2012-01-24 */ #define CLK_DIV 1 #define F_CPU 9600000UL/CLK_DIV //fréquence (9.6MHz/CLK_DIV) #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> // les 3 macros suivante (wdt_) ont été extraite de wdt.h et légèrement modifiées #define wdt_reset() __asm__ __volatile__ ("wdr":::) #define wdt_enable(value)\ __asm__ __volatile__ ( \ "in __tmp_reg__,__SREG__" "\n\t" \ "cli" "\n\t" \ "wdr" "\n\t" \ "out %0, %2" "\n\t" \ "out %1, %3" "\n\t" \ "out __SREG__,__tmp_reg__" "\n\t" \ "out %1,%4" \ : /* no outputs */ \ : "I" (_SFR_IO_ADDR(MCUSR)), \ "I" (_SFR_IO_ADDR(WDTCR)), \ "r" (_BV(WDRF)), \ "r" (_BV(WDCE) | _BV(WDE)), \ "r" ((uint8_t)(value & 0x6F))) #define wdt_disable()\ __asm__ __volatile__ ( \ "in __tmp_reg__, __SREG__" "\n\t" \ "cli" "\n\t" \ "out %0, %1" "\n\t" \ "out %0, __zero_reg__" "\n\t" \ "out __SREG__,__tmp_reg__" "\n\t" \ : /* no outputs */ \ : "I" (_SFR_IO_ADDR(WDTCR)), \ "r" ((uint8_t)(_BV(WDCE) | _BV(WDE)))) #define wdt_enable_interrupt() \ MCUSR &= ~(_BV(WDRF));\ WDTCR = _BV(WDCE) | _BV(WDE);\ WDTCR = _BV(WDTIE) | _BV(WDP0) | _BV(WDP3); #define led_off() DDRB &= 0xF0; #define read_adc() ADCSRA |= 1<<ADSC;\ while (ADCSRA & (1<<ADSC)); #if (CLK_DIV<8) #define CLKPS(x) (x/2) #else #define CLKPS(x) 3 #endif // constantes #define ANOD_LED0_1_2 PB0 #define ANOD_LED3_4_5 PB1 #define ANOD_LED6_7 PB2 #define CATH_LED0 PB1 #define CATH_LED1 PB2 #define CATH_LED2 PB3 #define CATH_LED3 PB0 #define CATH_LED4 PB2 #define CATH_LED5 PB3 #define CATH_LED6 PB0 #define CATH_LED7 PB1 #define BUTTONS PB4 #define LEFT_SWEEP -1 #define RIGHT_SWEEP 1 #define BTN_TRESHOLD 206 #define BTN_LEFT_MIN 185 #define BTN_LEFT_MAX 205 #define BTN_RIGHT_MIN 120 #define BTN_RIGHT_MAX 135 #define BTN_BOTH_MIN 105 #define BTN_BOTH_MAX 116 #define BTN_NONE 0 #define BTN_LEFT 1 #define BTN_RIGHT 2 #define BTN_BOTH 3 #define PLAYER_LEFT 0 #define PLAYER_RIGHT 1 #define BASE_SPEED 31 #define DEFAULT_SPEED 4*BASE_SPEED // vitesse de déplacement de la LED #define DLY_16SEC 2 // délais pour count_down 16 secondes // variables globales volatile uint8_t count_down=DLY_16SEC; // compte à rebours délais inactivité. uint8_t score[2]; // pointage des joueurs uint8_t player; // celui qui a le service uint8_t led_at_btn; //LED allumée lorsque le bouton a été enfoncé. void led_on(uint8_t led){// allume la LED désignée en argument uint8_t a=0,c=0; led_off(); PORTB &= 0xF0; switch (led){ case 0: c = 1<<CATH_LED0; a = 1<<ANOD_LED0_1_2; break; case 1: c = 1<<CATH_LED1; a = 1<<ANOD_LED0_1_2; break; case 2: c = 1<<CATH_LED2; a = 1<<ANOD_LED0_1_2; break; case 3: c = 1<<CATH_LED3; a = 1<<ANOD_LED3_4_5; break; case 4: c = 1<<CATH_LED4; a = 1<<ANOD_LED3_4_5; break; case 5: c = 1<<CATH_LED5; a = 1<<ANOD_LED3_4_5; break; case 6: c = 1<<CATH_LED6; a = 1<<ANOD_LED6_7; break; case 7: c = 1<<CATH_LED7; a = 1<<ANOD_LED6_7; break; default:; } DDRB |= a | c; PORTB |= a; } // led_on uint8_t delay_read_buttons(uint8_t msec){// delais en msec et leture boutons uint8_t smallest; read_adc(); smallest=ADCH; while (msec){ read_adc(); if (ADCH<smallest) smallest=ADCH; _delay_ms(1); msec--; } return smallest; } // delay_read_buttons uint8_t debounce_button(){ //20 lectures ADC consécutives identiques pour quitter. uint8_t previous, btn=0, count=0; read_adc(); previous=ADCH; while (count<20){ read_adc(); if (ADCH==previous) count++; else {previous=ADCH;count=0;} _delay_ms(1); } if (previous<=BTN_LEFT_MAX){ if (previous>=BTN_LEFT_MIN){ btn=BTN_LEFT; } else{ if (previous>=BTN_RIGHT_MIN){ btn=BTN_RIGHT; } else{ btn=BTN_BOTH; } } } return btn; } // debounce_button void display_byte(uint8_t byte){// affiche binaire de 'byte' sur la rangée de LEDs uint8_t led=0; while (delay_read_buttons(1)>BTN_TRESHOLD){ if ((byte & (1<<(7-led)))) led_on(led); else led_off(); led++; if (led>7) led=0; } while (delay_read_buttons(16)<BTN_TRESHOLD); } // display_byte uint8_t throw_ball(int8_t direction, uint8_t speed){//lancé de la balle vers l'autre joueur uint8_t hit, led, btn_val; if (direction==RIGHT_SWEEP){ led=0; } else{ led=7; } hit=0; while (led<=7){ led_on(led); btn_val=delay_read_buttons(speed); if (btn_val < BTN_TRESHOLD){ hit = 1; break; } led += direction; } if (hit) { led_at_btn=led; btn_val=debounce_button(); if (btn_val<=BTN_LEFT_MAX){ if (btn_val>=BTN_LEFT_MIN){ hit=BTN_LEFT; } else{ if (btn_val>=BTN_RIGHT_MIN){ hit=BTN_RIGHT; } else{ hit=BTN_BOTH; } } } if ((direction==LEFT_SWEEP && hit==BTN_LEFT) || (direction==RIGHT_SWEEP && hit==BTN_RIGHT) || (hit==BTN_BOTH)) hit=1; else hit=0; while (delay_read_buttons(16)<BTN_TRESHOLD); } return hit; } // throw_ball void wait_begin_signal(){// attend signal début partie uint8_t led; int8_t direction; led=0; direction=1; while (1){ led_on(led); if (delay_read_buttons(2)<BTN_TRESHOLD){ break; } if (led>7) direction = -direction; led += direction; } while (delay_read_buttons(16)<BTN_TRESHOLD); led_off(); if (led<4) player=PLAYER_LEFT; else player=PLAYER_RIGHT; } // wait_begin_signal void wait_service(){// attend le lancé du service uint8_t led, blink_cntr=0; if (player==PLAYER_LEFT){ led=0; } else{ led=7; } while (1){ if (blink_cntr<8) led_on(led); else led_off(); if (delay_read_buttons(16)<BTN_TRESHOLD) { if (debounce_button()==(player+1)) break; } blink_cntr++; blink_cntr &= 0xF; } while (delay_read_buttons(16)<BTN_TRESHOLD); led_off(); } // wait_service /* * une erreur c'est glissé dans iotn13a.h * BPDSE a été défini à la place de BODSE * BPDS a été défini à la place de BODS */ #define BODSE 0 #define BODS 1 ISR(WDT_vect){ // met le CPU en mode POWER DOWN après 16 secondes d'inactivité count_down--; if (!count_down){//power down led_off(); wdt_disable(); PORTB = 0 ; // désactivation des pullup BODCR = _BV(BODSE) | _BV(BODS); // désactivation Brownout dectect BODCR = _BV(BODS); ADCSRA &= ~(1<<ADEN); // désactivation ADC PRR |= _BV(PRTIM0) | _BV(PRADC); MCUCR = _BV(SE) | _BV(SM1); // mode power down __asm__ __volatile__ ("sleep":::); // les interruptions sont désactivées // un reset PB5 sera nésessaire pour redémarré. }else{ wdt_enable_interrupt(); } } int main( void ) { int8_t display, direction; uint8_t speed; // initialisation mcu CLKPR |= 1<<CLKPCE; CLKPR = CLKPS(CLK_DIV); // F_CPU 9.6Mhz/CLK_DIV // désactivation périphériques inutilisés ACSR |= _BV(ACD); // désactivation analog comparator DIDR0 |= _BV(ADC0D) | _BV(ADC1D) | _BV(ADC2D) | _BV(ADC3D); // désactivation entrées numériques inutilisées // initilasation watchdog timer wdt_enable((_BV(WDTIE)|_BV(WDP3)|_BV(WDP0))); // interruption sur timeout, diviseur 1024 sei(); // activation des interruptions // initialiation de l'ADC sur PB4 ADMUX= (1<<ADLAR) + 2; // résultat aligné à gauche, lecture canal 2. ADCSRA= (1<<ADEN) + 6; // activation ADC + diviseur=64 while ( 1 ) { // game loop wait_begin_signal(); if (player==PLAYER_LEFT){ direction=RIGHT_SWEEP; } else{ direction=LEFT_SWEEP; } speed=DEFAULT_SPEED; score[PLAYER_LEFT]=0; score[PLAYER_RIGHT]=0; wait_service(); while (1){ // throw loop wdt_reset(); count_down=DLY_16SEC; if(throw_ball(direction, speed)){ if (direction==LEFT_SWEEP){ speed=BASE_SPEED*(led_at_btn+1); } else{ speed=BASE_SPEED*(8-led_at_btn); } direction= -direction; } else{ if (direction==LEFT_SWEEP){ score[PLAYER_RIGHT]++; player=PLAYER_RIGHT; direction=LEFT_SWEEP; } else{ score[PLAYER_LEFT]++; player=PLAYER_LEFT; direction=RIGHT_SWEEP; } speed=DEFAULT_SPEED; wait_service(); } if (score[PLAYER_LEFT]==15 || score[PLAYER_RIGHT]==15){ // partie terminée. display=((int8_t)score[PLAYER_LEFT]<<4) + score[PLAYER_RIGHT]; display_byte(display); led_off(); break; } } } return 0; } // main

Je ne sais pas si vous avez remarqué mais les fabriquants donnent toujours la consommation d'énergie de leur MCU, en début de datasheet, au plus bas voltage de fonctionnement et à la fréquence de 1Mhz. Si on veut connaître la consommation à fréquence et voltage plus élevé il faut fouiller les données electrical characteristics à la fin du datasheet. Le fait est que la technologie CMOS a remplacé la technonologie NMOS du début 70's car elle consomme moins d'énergie. Sauf que la consommation augmente exponnentiellement avec la fréquence et le voltage.

Donc une des méthodes pour réduire la consommation d'un MCU est de le faire fonctionner à la plus basse fréquence que permet l'utilisation qu'on veut en faire. J'ai donc vérifier la consommation électrique du circuit à différentes fréquences et voltages. Voici le tableau des mesures obtenues:

Fosc	courant (Vdd=3.3V)	courant (Vdd=5V)	commentaire
9.6Mhz	7,00mA	14,68mA	sans désactivation périphériques
9.6Mhz	6,92mA	14,41mA	avec désactivation périphériques
4.8Mhz	6,11mA	13.21mA
2.4Mhz	5,37mA	11,9mA
1.4Mhz	5,03mA	11,3mA

Au lignes 345 et 346 je désactive les comparateurs analogiques et les entrées numériques qui ne sont pas utilisées dans cette application, ce qui permet de réduire à consommation d'à peine 270uA. Le fait est que dans cette application c'est le courant fourni à la LED allumée (il n'y en a jamais plus d'une à la fois) qui domine la consommation électrique. Ce n'est donc pas de cette façon qu'on peut réduire la consommation de façon significative. Par contre on constate que la réduction de la fréquence de l'oscillateur Fosc a plus d'effet ainsi que la réduction du voltage.

Dans ce cas particulié l'intérêt principal du power management est d'éviter que les piles se retrouvent à plat si on oubli d'éteindre le gadget. C'est là qu'entre en jeux les différents modes de mise en sommeil du MCU. Le WDT de l'atTiny13A possède un mode de fonctionnement appellé interrupt mode dans le datasheet. Dans ce mode lorsque la minuterie du watchdog timer expire une routine d'interruption est appellée plutôt que de produise un RESET du MCU. Je me sert donc de cette fonctionnalité. Le diviseur du WDT est programmé à 1024 ce qui donne un délais d'environ 8 secondes. De plus la variable count_down est utilisée pour prolonger ce délais en multiples de 8 secondes. l'ISR décrémente le compteur count_down et lorsque ce compteur arrive à zéro le MCU est mis en mode power down. Dans ce mode il ne consomme pratiquement plus de courant car tous les oscillateurs sont mis à l'arrêt. Mon multimètre indique que la consommation électrique passe de 14ma à 0,01ma (10uA). Je ne me fis pas trop à cette dernière lecture car elle est à la limite de résolution de mon multimètre. La consommation en mode power down avec une alimentation de 5 volts est probablement inférieur à 10uA et si le circuit était alimenté en 3 volt serait moindre.

Dans la procédure main il y a 2 boucles while (1) imbriquées. Dans le cycle de la boucle intérieure le WDT est réinitialisé ainsi que la variable count_down. Si les joueurs sont inactifs plus de 16 secondes la variable count_down tombe à zéro et le MCU est mis en mode power down. Le bouton RESET joue le rôle de power on et redémarre le MCU en mode normal.