wiki-se.plil.fr - Contributions [fr]

SE3 2025/2026 EC1

2026-04-14T18:25:31Z

Jramesh : /* Comparaison théorie VS pratique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}
<br>

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Média:Datasheet_arduino_uno.pdf|Datasheet arduino uno]] <br>
[[Média:Datasheet_AVR.pdf|Datasheet AVR]] <br>

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

<u> pour l'estimation de ma consommation: </u> <br>
. https://www.gammon.com.au/power <br>
. https://www.robot-maker.com/forum/blog/45/entry-41-tout-ce-que-vous-pourriez-vous-demander-sur-la-consommation-dune-puce-atmega328p-puce-darduino/ <br>

SE3 2025/2026 EC1

2026-04-14T18:25:05Z

Jramesh : /* Nota Bene */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Média:Datasheet_arduino_uno.pdf|Datasheet arduino uno]] <br>
[[Média:Datasheet_AVR.pdf|Datasheet AVR]] <br>

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

<u> pour l'estimation de ma consommation: </u> <br>
. https://www.gammon.com.au/power <br>
. https://www.robot-maker.com/forum/blog/45/entry-41-tout-ce-que-vous-pourriez-vous-demander-sur-la-consommation-dune-puce-atmega328p-puce-darduino/ <br>

SE3 2025/2026 EC1

2026-04-14T18:24:30Z

Jramesh : /* Nota Bene */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Média:Datasheet_arduino_uno.pdf|Datasheet arduino uno]] <br>
[[Média:Datasheet_AVR.pdf|Datasheet AVR]] <br>

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

<u> pour l'estimation de ma consommation: </u> <br>
. https://www.gammon.com.au/power
. https://www.robot-maker.com/forum/blog/45/entry-41-tout-ce-que-vous-pourriez-vous-demander-sur-la-consommation-dune-puce-atmega328p-puce-darduino/

Fichier:Datasheet AVR.pdf

2026-04-14T18:18:25Z

Jramesh :

SE3 2025/2026 EC1

2026-04-14T18:17:11Z

Jramesh : /* Documents utilisés */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Média:Datasheet_arduino_uno.pdf|Datasheet arduino uno]] <br>
[[Média:Datasheet_AVR.pdf|Datasheet AVR]] <br>

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T18:14:50Z

Jramesh : /* Documents utilisés */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Média:Datasheet_arduino_uno.pdf|Datasheet arduino uno]] <br>
[[Média:Datasheet_AVR.ogg|Datasheet AVR]] <br>

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T18:08:35Z

Jramesh : /* Documents utilisés */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Média:Datasheet_arduino_uno.ogg|Datasheet arduino uno]] <br>
[[Média:Datasheet_AVR.ogg|Datasheet AVR]] <br>

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T18:05:29Z

Jramesh : /* Historique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 19h57 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T18:05:18Z

Jramesh : /* Historique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie) <br>
_ 05/04 17h23 : Ajout des calculs pour l'estimation de la consommation théorique + rajout des photos de la consommation expérimentale + rajout des sources

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T18:00:25Z

Jramesh : /* Comparaison théorie VS pratique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) par les composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:59:32Z

Jramesh : /* 6. modélisation de la consommation théorique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== <span style="color:#800020;font-weight: bold;">Mode Veille (Power Down) </span> ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== <span style="color:#800020;font-weight: bold;"> Comparaison théorie VS pratique </span> ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:58:18Z

Jramesh : /* 6. modélisation de la consommation théorique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">Mode Actif (Blink) </span> ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== Mode Veille (Power Down) ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== Comparaison Théorie vs Pratique ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:56:20Z

Jramesh : /* 5. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== Mode Actif (Blink) ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== Mode Veille (Power Down) ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== Comparaison Théorie vs Pratique ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:54:36Z

Jramesh : /* 5. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'une seule, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 0 || éteintes || 0.00 || 5.11 || 3 branchées, aucune activée
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== Mode Actif (Blink) ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== Mode Veille (Power Down) ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== Comparaison Théorie vs Pratique ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:54:03Z

Jramesh : /* Travail réalisé */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 0 || éteintes || 0.00 || 5.11 || 3 branchées, aucune activée
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

=== <span style="color:#800020;font-weight: bold;">6. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== Mode Actif (Blink) ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== Mode Veille (Power Down) ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== Comparaison Théorie vs Pratique ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:50:30Z

Jramesh : /* 5. modélisation de la consommation théorique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== Mode Actif (Blink) ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== Mode Veille (Power Down) ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== Comparaison Théorie vs Pratique ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 0 || éteintes || 0.00 || 5.11 || 3 branchées, aucune activée
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:50:19Z

Jramesh : /* 5. modélisation de la consommation théorique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===
=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

Si mon code est optimisé pour limiter la consommation du microcontrôleur, une carte Arduino embarque pourtant d'autres composants qui restent toujours sous tension et consomment de l'énergie en permanence, même en mode Power Down.

==== Mode Actif (Blink) ====
Dans ce mode, tous les composants fonctionnent à plein régime.
* '''Microcontrôleur (ATmega328P)''' : ~15 à 20 mA
* '''Puce USB-vers-Série ''' : ~15 mA (toujours allumée).
* '''LED de tension (Power)''' : ~3 à 5 mA.
* '''Régulateur de tension''' : ~2 à 5 mA (au repos).
* '''LED "L" (Pin 13)''' : ~3 mA (allumée durant blink).
* '''Total estimé : ~40 à 50 mA'''

==== Mode Veille (Power Down) ====

* '''Microcontrôleur (ATmega328P)''' : ~ 5 µA. ''grâce au mode power down + mes autres optimisations supplémentaires''
* '''Puce USB-vers-Série''' : ~15 mA. ''(Impossible à éteindre par code)''
* '''LED de tension (Power)''' : ~3 à 5 mA. ''(Toujours allumée)''
* '''Régulateur de tension''' : ~2 à 5 mA. ''(Toujours actif)''
* '''LED "L" (Pin 13)''' : 0 mA. ''(Éteinte)''
* '''Total estimé : ~25 à 35 mA'''

==== Comparaison Théorie vs Pratique ====
En reprenant les données mesurées avec la clé USB sur le hub pour 3 Arduinos, on peut en déduire la consommation réelle d'une seule carte et la comparer à notre théorie :

{| class="wikitable" style="text-align: center; margin: auto;"
|+ Comparaison Consommation : Théorie vs Mesures (pour 1 Arduino Uno)
|-
! Mode !! Estimation Théorique !! Mesure Réelle Déduite !! Remarques
|-
| '''Blink''' || ~40 à 50 mA || ~43 mA ''(130 mA / 3)'' || Cohérent avec la théorie.
|-
| '''Power Down''' || ~25 à 35 mA || ~36 mA ''(110 mA / 3)'' || Cohérent. La très légère surconsommation s'explique (d'après mon hypothèse) des composants des clones de l'arduino qui seraient un peu plus gourmands en consommation.
|}

'''Conclusion :'''
Le code fait bien son travail et permet d'économiser environ '''10 mA''' en endormant le microcôntroleur. Néanmoins, à cause des puces secondaires inhérentes à la carte, celle ci ne descend pas en dessous d'une trentaine de milliampères.

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 0 || éteintes || 0.00 || 5.11 || 3 branchées, aucune activée
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:26:48Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 0 || éteintes || 0.00 || 5.11 || 3 branchées, aucune activée
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:23:15Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

'''Petit résumé : '''
{| class="wikitable" style="text-align: center; margin: auto;"
|+ Résumé de la consommation des Arduinos
|-
! Nombre d'Arduinos !! Mode !! Courant (A) !! Tension (V) !! Remarques
|-
| 0 || Aucune (éteintes) || 0.00 || 5.11 || 3 branchées, aucune activée
|-
| 1 || Power down / Blink || 0.00 || 5.11 || Consommation trop faible pour être détectée par la clé
|-
| 2 || Power down || 0.07 || 5.08 ||
|-
| 2 || Blink || 0.09 || 5.07 ||
|-
| 3 || Power down || 0.11 || 5.07 ||
|-
| 3 || Blink || 0.13 || 5.07 ||
|}

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

Fichier:3on high.jpg

2026-04-14T17:19:48Z

Jramesh :

Fichier:3on low.jpg

2026-04-14T17:18:24Z

Jramesh :

SE3 2025/2026 EC1

2026-04-14T17:17:38Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:3on_high.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

Fichier:2on 1 off high.jpg

2026-04-14T17:14:21Z

Jramesh :

Fichier:2on 1 off low.jpg

2026-04-14T17:12:46Z

Jramesh :

SE3 2025/2026 EC1

2026-04-14T17:12:24Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]]
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down'''<br />
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:11:07Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]] <br />
'''1 arduino allumée''', '''La consommation en blink est identique à celle en mode power down''' <br>
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:10:55Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]] <br />
'''1 arduino allumée''', La '''consommation en blink est identique à celle en mode power down''' <br>
la clé ne prend tout simplement pas en compte la consommation d'une arduino seule
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:10:09Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down''' <br>
''' la clé ne prend tout simplement pas en compte la consommation d'une arduino seule"
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:09:57Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down'''
''' la clé ne prend tout simplement pas en compte la consommation d'une arduino seule"
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

Fichier:One switched.jpg

2026-04-14T17:08:11Z

Jramesh :

SE3 2025/2026 EC1

2026-04-14T17:06:21Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]
'''3 arduinos branchées, aucune allumée '''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:05:07Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg|center|300px]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg|center|300px]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg|center|300px]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:03:40Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

[[Fichier:all_plugged_none_switched.jpg|center|300px|0 arduinos allumées]]

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T17:02:58Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

[[Fichier:all_plugged_none_switched.jpg|thumb|300px|0 arduinos allumées]]

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

Fichier:All plugged none switched.jpg

2026-04-14T17:00:14Z

Jramesh :

SE3 2025/2026 EC1

2026-04-14T16:58:32Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg]] <br />
'''0 arduinos allumées'''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino allumée, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''2 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg]] <br />
'''2 arduinos allumées, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg]] <br />
'''3 arduinos allumées, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''3 arduinos allumées, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T16:57:36Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant aucune :

<div style="text-align: center;">
[[Fichier:all_plugged_none_switched.jpg]] <br />
'''0 arduinos ON'''
</div>

J'ai ensuite branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino ON, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''2 arduinos ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg]] <br />
'''2 arduinos ON, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg]] <br />
'''3 arduinos ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''3 arduinos ON, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T16:49:56Z

Jramesh : /* 4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino ON, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''2 arduino ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg]] <br />
'''2 arduino ON, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg]] <br />
'''3 arduino ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''3 arduino ON, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T16:49:39Z

Jramesh : /* 6. Consommation expérimentale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino ON, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''2 arduino ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg]] <br />
'''2 arduino ON, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg]] <br />
'''3 arduino ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg]] <br />
'''3 arduino ON, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T16:46:55Z

Jramesh : /* 6. mesure de la consommation totale */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. Consommation expérimentale </span> ===

J'ai d'abord branché les 3 arduinos sur le hub en n'en allumant qu'un seul, tout comme la dernière fois, les consommations en blink et en hibernation sont les mêmes :

<div style="text-align: center;">
[[Fichier:one_switched.jpg]] <br />
'''1 arduino ON, La consommation en blink est identique à celle en mode power down'''
</div>

En activant deux Arduino et en synchronisant leurs clignotements, on observe que :

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg] <br />
'''2 arduino ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_high.jpg] <br />
'''2 arduino ON, Consommation en mode blink '''
</div>

Enfin, en activant les 3 arduinos on obtient :

<div style="text-align: center;">
[[Fichier:3on_low.jpg.jpg] <br />
'''3 arduino ON, Consommation en mode power down '''
</div>

<div style="text-align: center;">
[[Fichier:2on_1_off_low.jpg] <br />
'''3 arduino ON, Consommation en mode blink '''
</div>

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-14T14:57:25Z

Jramesh : /* Travail réalisé */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

=== <span style="color:#800020;font-weight: bold;">6. mesure de la consommation totale </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:32:11Z

Jramesh : /* Historique */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16h16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C <br>
_ 05/04 17h23 : Ajout de la partie sur la modélisation théorique de consommation (non remplie)

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:28:22Z

Jramesh : /* 5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. modélisation de la consommation théorique </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:27:10Z

Jramesh : /* 4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:26:33Z

Jramesh : /* IV. Utilisation du WatchDog, registre WDTCSR */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci-dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog reglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:26:13Z

Jramesh : /* IV. Utilisation du WatchDog, registre WDTCSR */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le réveiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog reglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:25:46Z

Jramesh : /* III. Désactivation des Clocks des périphériques non utilisés */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déjà fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le révéiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog reglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:25:24Z

Jramesh : /* III. Désactivation des Clocks des périphériques non utilisés */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le système ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déja fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le révéiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog reglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:24:26Z

Jramesh : /* II. Désactivation des Interruptions, SREG, cli( ) et sei( ) */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci-dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le sytème ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déja fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le révéiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog reglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>

SE3 2025/2026 EC1

2026-04-05T15:23:58Z

Jramesh : /* I. registre SMCR et header sleep.h */

= <span style="color:#A45B3D;font-weight: bold;"> Objectifs </span> =

Réaliser le programme d’économie d’énergie du cours/TP concernant la programmation sur microcontrôleur AVR :

* le programme fait clignoter la LED de la carte plusieurs fois rapidement ;
* le programme entre alors en hibernation pendant plusieurs secondes ;
* évaluez la consommation dans deux implantations différentes :
**hibernation réalisée avec un simple <code>_delay_ms</code>,
**hibernation réalisée avec une mise en sommeil de l’ATmega328p.

Vous tenterez aussi de comprendre vos résultats empiriques :
* modélisez la consommation théorique en prenant en compte les principaux composants de l'Ardunio Uno ;
* comparez avec les mesures effectuées.

= <span style="color:#A45B3D;font-weight: bold;"> Matériel nécessaire </span> =

* Arduino Uno avec câble USB ;
* Dispositif de mesure de la consommation sur un port USB.

= <span style="color:#A45B3D;font-weight: bold;"> Historique </span> =

_ 20/02 23h35 : première modification du wiki, rajout "Historique" + update "travaux réalisés" <br>
_ 22/02 00h05 : Ajout de la datasheet de l'arduino uno + rajout "Documents utilisés" <br>
_ 22/02 02h40 : Ajout de blink.c + instructions de compilations <br>
_ 24/02 23h46 : Ajout de blink.mp4 ( démonstration de blink.c ) <br>
_ 26/02 11h25 : Ajout veille_delay.c + instructions de compilations <br>

Problème Majeur : il me semble que la clé évaluant la consommation d'énegie de mon arduino ne marche pas. Cela se voit d'abord dans blink.mp4 où le compteur est immobile,
de même pour veille_delay.mp4 que je n'ai pas encore téléversé.
Ainsi, je vais continuer à travailler mes codes pour l'instant et je repasserai sur la partie consommation quand j'aurai les moyens de le faire.

_ 26/02 14~15 : Modifications esthétiques <br>
_ 26/02 16h47 : Ajout de ma justification de méthode de veille de l'ATmega328P <br>
_ 27/02 15h-00h42 : Ajout des éléments I, II, III, IV dans la partie justification du code + Ajout de power_down.c + modifications mineures <br>

_ 05/04 16:16 : gestion du sommeil et du watchdog à l'aide de registres et non de fonctions, comme demandé, au sein du nouveau code : power_down2.c + instruction de compilation + corrections de coquilles mineures <br> je teste la clé dès que je mets la main sur un câble usb-B usb-C

= <span style="color:#A45B3D;font-weight: bold;"> Travail réalisé </span> =

Afin de se rendre la tâche plus facile nous allons nous découper le code en plusieurs morceaux,
* <code>blink.c</code> -> pour faire clignoter la led,
* <code>veille_delay.c</code> -> code pour mettre l'arduino en veille avec la méthode du <code>_delay_ms</code>,
* <code>power_down.c</code> -> pareil avec la deuxième méthode.

Tout code disponible sur le Wiki :
=== <span style="color:#800020;font-weight: bold;">1. blink.c </span> ===
<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes

int main (){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
return 0;
}
</syntaxhighlight>

* pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o blink.elf blink.c
avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex
</syntaxhighlight>

* pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:blink.hex
</syntaxhighlight>

<div style="text-align: center;">
[[Fichier:blink.mp4.mp4]] <br />
'''Démonstration blink.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">2. veille_delay.c </span> ===
Ce code permet de faire clignoter la led 5 fois avant d'entrer en hibernation par un _delay_ms de 3 secondes

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#define BLINK_DELAY 500 // en milli secondes
#define VEILLE_DELAY 3000 // en ms

int main (){
while (1){
// configurer la led en sortie :
DDRB |= (1 << 5); // PORTB 5e bit pour la led

for(int i=0; i<5 ; i++){
// led on
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);

// led off
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
// hibernation
_delay_ms(VEILLE_DELAY);
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o veille_delay.elf veille_delay.c
avr-objcopy -j .text -j .data -O ihex veille_delay.elf veille_delay.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:veille_delay.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_veille_delay.mp4]] <br />
'''Démonstration veille_delay.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">3. power_down.c </span> ===
==== <span style="color:#800020;font-weight: bold;">3.a) Justification de mon choix de méthode de veille </span> ====

D'après la datasheet avr de l'atmega328P, il existe 6 modes différents de mise en veille :
<div style="text-align: center;">
[[Fichier:sleep_modes.png|centré|sans_cadre|900x900px]] <br />
''' Tables des différentes méthodes de mise en Veille de l'ATmega32P''' <br>
''' source : datasheet avr ATmega328P '''
</div>

La méthode utilisant le moins d'énergie serait par logique celle qui utilise le '''moins de ressources possibles''', c'est-à-dire qui désactive le plus de Clocks possible. <br>
Ici il semblerait que ce soit la méthode '''"Power Down"'''. <br>

Mais encore, mon choix s'affirme une seconde fois car il nous est pas demandé d'utiliser une interruption extérieure pour permettre à l'arduino de se réveiller, et plus il existe de manières de réveiller l'ATmega plus elle consommera d'énergie.
Nous partirons ainsi sur la méthode qui utilise le moins de Wake up sources : Power Down.
Le seul point à respecter étant que l'ATmega soit '''capable de se réveiller d'elle même''', c'est-à-dire en utilisant son WatchDog, condition qui est respectée. <br>
On utilise le timer du WatchDog car '''_delay_ms''' n'est '''pas utilisable''' en mode Power Down.

==== <span style="color:#800020;font-weight: bold;">3.b) Justification des éléments du code </span> ====
===== <span style="color:#800020;font-weight: bold;"> I. registre SMCR et header sleep.h </span> =====

Afin de faire entrer l'ATmega en mode '''Power Down''' il suffit de modifier le registre SMCR (Sleep Mode Control Register)

<div style="text-align: center;">
[[Fichier:SMCR.png|centré|sans_cadre|900x900px]] <br />
'''Registre SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Pour entrer en mode '''Power Down''' spécifiquement :
<div style="text-align: center;">
[[Fichier:bit_order.png|centré|sans_cadre|900x900px]] <br />
''' Arrangement des bits SMCR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Ce qui ressemblerait à :
<syntaxhighlight lang="c" line="1">
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
</syntaxhighlight>

Cependant, la procédure de mise en sommeil est plus complexe car elle nécessite aussi l'utilisation de l'instruction assembleur '''sleep''' <br>
Pour y pallier (même dans la documentation officielle du site Microchip sur les AVR), on utilise les fonctions <code>set_sleep_mode();</code> et <code>sleep_mode();</code> toutes deux provenant du header '''<avr/sleep.h>'''. <br>
'''set_sleep_mode() :''' Cette fonction correspond exactement à notre ligne de code précédente quand on y passe l'argument SLEEP_MODE_PWR_DOWN <br>
'''sleep_mode() :''' C'est la partie "complexe" car elle s'occupe non seulement de l'instruction sleep mais aussi de mettre le bit SE (Sleep Enable) du SMCR à une valeur de 1 (Nécessaire pour plonger le MCU en mode sleep)... <br>

En utilisant ces deux fonctions conformément à la documentation Microchip, on obtient :
<syntaxhighlight lang="c" line="1">
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
</syntaxhighlight>

'''Attention !''' : en sleep_mode( ), l'ATmega ne répondra plus à rien, seul l'interruption du watchdog pourra la réveiller, donc toujours mettre cette instruction en fin de code lorsqu'il ne reste plus rien à faire.

Pourtant, on peut aussi tout faire avec les registres : <br>
en modifiant le bit '''SE ( sleep enable ) ''' de SMCR en le mettant à 1.<br>
Couplé à l'instruction : <code> asm("SLEEP") </code> qui remplace la fonction "sleep()". <br>
<syntaxhighlight lang="c" line="1">
SMCR = (1 << SE);
asm("SLEEP");
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> II. Désactivation des Interruptions, SREG, cli( ) et sei( ) </span> =====

Même en mode '''Power Down''' il ne faut pas oublier de désactiver les interruptions globales. <br>
En effet, on a vu auparavant tous les types d'interruptions que le mode Power Down permet. Or, pour éviter d'interrompre le timer du watchdog, il faut manuellement les désactiver. <br>
Soit en utilisant le registre SREG et en travaillant avec le bit 7 comme indiqué ci dessous : <br>

<div style="text-align: center;">
[[Fichier:SREG.png|centré|sans_cadre|900x900px]] <br />
'''Registre SREG''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit en utilisant directement la fonction "'''cli( )'''" puis en réactivant les interruptions à la fin du code avec "'''sei( )'''" contenus dans le header <avr/interrupt.h>. <br>

===== <span style="color:#800020;font-weight: bold;"> III. Désactivation des Clocks des périphériques non utilisés </span> =====

Même si le mode '''Power Down''' est activé, il est préférable de désactiver manuellement toutes les clocks qui ne nous sont pas utile afin d'économiser un maximum d'énergie. <br>
En sachant que nous n'utilisons que le watch dog, le reste peut être désactivé. <br>
Principalement le système "'''ADC'''" ( je n'ai pas réussi à parfaitement comprendre ce qu'il fait, mis à part assurer la capacité de l'ATmega à utiliser ses pins, mais j'ai compris qu'il était gourmand en énergie et je n'utilise pas de pins dans ce code, donc autant le désactiver pour gagner de l'énergie). <br>

Puis ensuite désactiver les clocks des périphériques non utilisés (SPI, timer...).

Pour éteindre le sytème ADC il suffit de modifier la '''bit 7 du registre ADCSRA: '''
<div style="text-align: center;">
[[Fichier:ADCSRA.png|centré|sans_cadre|900x900px]] <br />
'''Registre ADCSRA''' <br>
''' source : datasheet avr ATmega328P '''
</div>

Soit : <code> ADCSRA &= ~(1 << 7); </code> ou pour plus de lisibilité : <code> ADCSRA &= ~(1 << ADEN); </code> avec EN pour "Enable"

Puis, il faut désactiver les clocks, toutes sauf celle de la watchdog car c'est la seule que l'on utilisera. <br>

en important le header ''' <avr/interrupt.h> '''
<syntaxhighlight lang="c" line="1">
// power_adc_disable(); ( déja fait précédemment )
power_usart0_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
</syntaxhighlight>

Ce qui peut être résumé par : <br>
<syntaxhighlight lang="c" line="1">
power_all_disable ();
</syntaxhighlight>

évidemment il ne faut pas oublier de réactiver les clocks pour pouvoir utiliser delay_ms() pour faire clignoter la led après le réveil de l'ATmega. <br>
<syntaxhighlight lang="c" line="1">
power_all_enable ();
</syntaxhighlight>

===== <span style="color:#800020;font-weight: bold;"> IV. Utilisation du WatchDog, registre WDTCSR </span> =====

En sachant qu'en mode Power Down, nous n'avons pas accès à _delay_ms(), on utilisera le WatchDog. <br>
Pour cela supposons que l'on veut mettre l'ATmega en mode Power Down pendant 4 secondes ( temps de sommeil de l'ATmega ) <br>

Il faudra alors établir un timer, en utilisant le registre WDTCSR

<div style="text-align: center;">
[[Fichier:WDTCSR.png|centré|sans_cadre|900x900px]] <br />
'''Registre WDTCSR''' <br>
''' source : datasheet avr ATmega328P '''
</div>

<div style="text-align: center;">
[[Fichier:timer.png|centré|sans_cadre|900x900px]] <br />
'''Soit 512k cycle pour 4s ''' <br>
''' source : datasheet avr ATmega328P '''
</div>
Pour pouvoir modifier le timer WatchDog, il faut d'abord reset le WatchDog avec <code> wdt_reset(); </code> <br>
Puis avant de pouvoir lui ordonner de compter nos 4 secondes il faut pouvoir le modifier, pour cela on utilise les bit WDCE et WDE. <br>
'''WDCE (Watchdog Change Enable) :''' Tant qu'il est à 0, toute écriture sur les bits de durée est ignorée par le hardware, donc il faut le mettre à 1. <br>
'''WDE (Watchdog System Reset Enable) : ''' Son rôle ne m'est pas vraiment clair mais la documentation de chez Microchip impose que WDE soit fixé à 1 pour modifier le timer. <br>

Aussi faut-il mettre à 1 le bit '''WDIE (Watchdog Interrupt Enable)''' qui permet au watchdog "d'interrompre" l'ATmega et ainsi de le révéiller. <br>
On met aussi le bit '''WDP3 à 1''' pour avoir un timer de '''4s''' comme indiqué ci dessus.

Soit : <br>
<syntaxhighlight lang="c" line="1">
wdt_reset();
WDTCSR |= (1<<WDCE) | (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);

</syntaxhighlight>

==== <span style="color:#800020;font-weight: bold;">3.c) Code power_down.c et instructions de compilation </span> ====

<syntaxhighlight lang="c" line="1">
#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();

blink_module();
// setting power down mode
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// reset watchdog timer
wdt_reset();
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog réglé on peut dormir
sleep_mode();
// une fois que 4s sont écoulés, sortie de veille:
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down.elf power_down.c
avr-objcopy -j .text -j .data -O ihex power_down.elf power_down.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down.mp4]] <br />
'''Démonstration power_down.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">4. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

<syntaxhighlight lang="c" line="1">

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
//#include <avr/wdt.h>
//#include <avr/sleep.h>

#define BLINK_DELAY 320 // ms

void blink_module(){
for(int i=0; i <= 3; i++){
//led ON
PORTB |= (1 << 5); // OR
_delay_ms(BLINK_DELAY);
//led OFF
PORTB &= ~ (1 << 5); // AND + NOT
_delay_ms(BLINK_DELAY);
}
}

int main(){
// PB5 en sortie
DDRB |= (1 << 5);
// désactivation de l'ADC
ADCSRA &= ~(1 << ADEN);
while(1){
// désactivation interruptions globales
cli();
// désactivations clocks inutiles
power_all_disable();
// call blink
blink_module();
// setting power down mode
SMCR = (0 << SM2) | (1 << SM1) | (0 << SM0);
// reset watchdog timer
asm( "WDR ");
// WatchDog timer de 4s
WDTCSR |= (1<<WDCE)| (1<<WDE);
WDTCSR = (1 << WDIE)| (1<<WDP3);
// reactivation des interruptions
sei();
// une fois le watchdog reglé on peut dormir
SMCR = (1 << SE);
asm("SLEEP");
// une fois que 4s sont écoulés, sortie de veille:
SMCR &= ~(1 << SE);
// reactivation des clocks (pour _delay_ms)
power_all_enable();
}
return 0;
}
</syntaxhighlight>

Pour compiler :
<syntaxhighlight lang="bash">
avr-gcc -mmcu=atmega328p -Wall -Werror -I. -DF_CPU=16000000 -Os \
-o power_down2.elf power_down2.c
avr-objcopy -j .text -j .data -O ihex power_down2.elf power_down2.hex
</syntaxhighlight>

Pour mettre le code en flash :
<syntaxhighlight lang="bash">
avrdude -v -patmega328p -carduino -b115200 -P/dev/ttyACM0 \
-U flash:w:power_down2.hex
</syntaxhighlight>

<div style="text-align: center;">
[[2025_EC1_power_down2.mp4]] <br />
'''Démonstration power_down2.c'''
</div>

=== <span style="color:#800020;font-weight: bold;">5. Version avec registre pour la gestion du watchdog et de la mise en sommeil : power_down2.c </span> ===

= <span style="color:#A45B3D;font-weight: bold;"> Documents utilisés </span> =
[[Datasheet_arduino_uno.pdf]] <br>
[[Datasheet_AVR.pdf]]

= <span style="color:#A45B3D;font-weight: bold;"> Nota Bene </span> =

* Problème majeur rencontré : dysfonctionnement de l'outil de mesure de consommation d'énergie <br>

* Inspiration esthétique de ma page wiki prise de Kaoutar El Bachiri <br>
(https://wiki-se.plil.fr/mediawiki/index.php/SE5_IdO_s%C3%A9curit%C3%A9_des_objets_2025/2026_b2)

* Sites utilisés : <br>
<u> pour la justification du choix de mode de veille et la construction de mon code : </u> <br>
. https://www.ewskills.com/arduino/sleep-modes <br>
. https://circuitdigest.com/microcontroller-projects/arduino-sleep-modes-and-how-to-use-them-to-reduce-power-consumption <br>
. https://wolles-elektronikkiste.de/en/sleep-modes-and-power-management#Anker2 <br>
. https://www.avrfreaks.net/s/topic/a5C3l000000UcdbEAC/t162315 <br>
. https://onlinedocs.microchip.com/oxy/GUID-EAD481FD-28E6-4CD5-87FB-5165E7687C12-en-US-5/GUID-3B54E66E-AE92-459F-99E6-EF5B8655258F.html <br>