Arduino faible consommation

Dans ce tutoriel nous allons concevoir un Arduino minimaliste à base du micro-contrôleur ATmega328P. L’objectif étant de minimiser la consommation électrique afin de pouvoir réaliser par la suite des montages ayant une autonomie de plusieurs mois tout en étant alimentés sur pile.

Mots clés : Arduino ; ATmega328P; Faible consommation

Le matériel :

• Arduino Uno
• ATmega328 (version avec bootloader Arduino intégré)
• Convertisseur USB-Série
• Condensateurs 2x22 pF + 1x10 µF + 1x100nF
• Résistance 1k

Programme de référence

Afin d’avoir une référence commune aux différents tests, nous utiliserons un programme très simple qui allume une LED pendant 5 secondes, puis l’éteint pendant 5 secondes, le cycle se répétant ainsi toutes les 10 secondes.
La durée de 5 secondes est nécessaire pour stabiliser l’affichage du multimètre lorsque nous mesurons le courant.

// fonction qui s'execute une fois au demarrage de l'arduino ou après un reset
void setup() {
  // initialise la pin 13 (LED_BUILTIN) comme une sortie
  pinMode(LED_BUILTIN, OUTPUT);
}

// fonction qui s'execute en boucle
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // allume la LED
  delay(5000);                       // attend 5 secondes
  digitalWrite(LED_BUILTIN, LOW);    // eteint la LED
  delay(5000);                       // attend 5 secondes
}

Mesure de la consommation d’un Arduino Uno

L’Arduino Uno a une tension de fonctionnement de 5 V, il peut être alimenté de plusieurs façons :

1. Prise USB (5 V)
2. Connecteur jack (7-12 V)
3. Broche VIN de l’Arduino (7-12 V)
4. Broche 5V de l’Arduino (5 V)

L’alimentation par le connecteur jack est protégée par une diode qui évite d’endommager la carte en cas de mauvais branchement.
Par contre l’alimentation par les broches « VIN » et « 5V » ne sont pas protégées et il faudra donc être prudent sur le branchement afin de ne pas endommager l’Arduino.
Le connecteur jack et la broche « VIN » sont reliés à un régulateur de tension LDO qui convertie la tension d’entrée (7-12 V) en 5 V pour alimenter la carte.
La prise USB et la broche « 5V » alimentent directement la carte sans passer par le régulateur de tension.

Note : l’Arduino Uno est équipé d’un régulateur 3,3 V dont la sortie est connectée à la broche « 3.3V ». On peut s’en servir pour alimenter un circuit externe en 3,3 V. Mais attention cette broche est uniquement une sortie et l’Arduino ne peut donc pas être alimenté en 3,3 V via cette broche.

Après avoir téléversé le programme de référence dans notre Arduino Uno, nous mesurons sa consommation à l’aide d’un multimètre.

Nous voyons que l’Arduino consomme plus de courant lorsque il est alimenté par la broche VIN, ce qui est normal car le régulateur de tension LDO consomme environ 10 mA. Nous remarquons également que l’impact d’une LED allumée sur la consommation du circuit est d’environ 4 mA. Il faudra donc éviter l’utilisation de LED et de régulateur de tension pour la réalisation de notre montage à faible consommation.

Autonomie : Notre Arduino Uno consomme donc 41 mA au minimum dans sa configuration de base, ce qui limite l’autonomie à 24h en utilisant une pile ou batterie de 1000 mAh par exemple (41 mA * 24 h = 984 mAh).
Afin de garantir une autonomie sur pile ou batterie d’environ 1 an, notre micro-contrôleur doit consommer moins de 100 µA (0,1 mA), il va donc falloir réduire drastiquement la consommation électrique de notre montage.
C’est l’objectif de la partie suivante, dans laquelle nous réduirons le nombre de composants au minimum en n’utilisant que le micro-contrôleur ATmega328P.

Conception minimaliste à base du micro-contrôleur ATmega328P

Le micro-contrôleur ATmega328P est le cœur de l’Arduino, et il est possible de se le procurer en tant que composant nu sur les différents sites de commerce en ligne

La fiche technique de l’ATmega328P indique que la tension d’alimentation du composant doit être comprise entre 1.8 V et 5.5 V. L’utilisation d’une batterie Li-Ion de 3,7 V est donc idéale pour notre test puisque sa tension maximale est de 4,2 V et sa tension nominale de 3,7 V.

Afin d’avoir la configuration la plus proche possible de notre Arduino Uno, nous utilisons les composants suivants pour notre conception minimale :

• Une résistance de 10 kΩ entre la broche  » RESET » et VCC (reset à l’état bas) – lire cet article pour comprendre son rôle
• Un oscillateur externe à 16 MHz (1 crystal 16 MHz + 2 condensateurs 22 pF)
• Un condensateur de 10 µF entre GND et VCC afin d’éviter les pics de tension (optionnel avec l’utilisation d’une batterie)

Schéma électrique correspondant :

Téléchargement du bootloader sur l’ATmega328P

Afin de pouvoir utiliser l’IDE Arduino pour programmer notre ATmega328P, il faut qu’un programme spécifique soit installé dans une zone particulière de la mémoire flash de l’ATmega328P.
Ce petit programme est appelé bootloader et il est normalement installé par défaut sur les puces ATmega328P.
Si le bootloader n’est pas installé sur votre puce, l’installation peut se faire via un Arduino Uno utilisé comme ISP (In-circuit Serial Programmer).

Tout d’abord il faut relier l’Arduino Uno à l’ATmega328P via une liaison SPI. Il faut également relier la broche RESET de l’ATmega328P à la broche 10 de l’Arduino Uno.

Pour télécharger le bootloader sur l’ATmega328P suivre cette procédure avec l’IDE Arduino :

1. Connecter l’Arduino Uno au PC via un câble USB et sélectionner la carte Arduino Uno (Outils/Type de carte/Arduino Uno) et le port USB correspondant
2. Téléverser le croquis ArduinoISP (Fichiers/Exemples/11.ArduinoISP/ArduinoISP ) sur l’Arduino Uno
3. Sélectionner le programmateur « Arduino as ISP  » (Outils/programmateur/Arduino as ISP)
4. Grave la séquence d’initialisation sur l’ATmega328P (Outils/Graver la séquence d’initialisation)

Vous venez de télécharger le bootloader sur votre puce ATmega328P !

Téléversement d’un programme sur l’ATmega328P

L’utilisation d’un convertisseur USB vers série (FTDI) permet de téléverser un programme de l’IDE Arduino directement sur l’ATmega328P via son port série.

⚠ Attention certains convertisseurs nécessitent d’installer un driver. Par exemple le convertisseur vendu par Gotronic nécessite de télécharger les drivers sur le site de FTDI.

Relier les broches du FTDI et de l’ATmega328P de la façon suivante :

Vous pouvez bien entendu alimenter votre breadboard avec l’alimentation fournie par le FTDI (un switch vous permet d’alimenter en 3,3 V ou 5 V)

Procédure à suivre pour téléverser votre programme sur le micro-contrôleur :

1. Sélectionner la carte « Arduino Uno » (Outils/Type de carte/Arduino Uno)
2. Sélectionner le port USB sur lequel est connecté le FDTI
3. Téléverser le programme

Le programme s’exécute maintenant sur votre ATmega328P, vous pouvez vérifier le clignotement de la LED (reliée à la sortie D13 (broche 19) de l’ATmega328P, ne pas oublier de mettre une résistance 470 Ω.

Il est temps de mesurer la consommation de cette conception minimaliste.
Après avoir téléversé notre programme de référence, nous observons que la consommation de courant est maintenant de 9 mA.

En comparaison à la consommation de l’Arduino Uno pour le même programme (41 mA), le gain est significatif.
Mais cette consommation est toujours bien trop importante pour envisager un dispositif sur batterie.

Optimisation de la consommation du micro-contrôleur ATmega328P

Utilisation de l’oscillateur interne

Notre utilisation du micro-contrôleur ne nécessite pas une grande précision d’horloge, aussi nous utiliserons son oscillateur interne.

Il faut éditer le fichier « boards.txt » qui se trouve dans le répertoire d’installation de l’IDE (exemple sur mon PC Linux : /opt/arduino-1.8.12/hardware/arduino/avr/boards.txt) afin d’y ajouter la configuration de notre micro-contrôleur ATmega328P utilisant son oscillateur interne à 8 MHz.

Ajoutez ces lignes à la fin du fichier « boards.txt, puis relancer l’IDE.

##############################################################
atmega328bb.name=ATmega328 8 MHz internal clock
atmega328bb.upload.tool=avrdude
atmega328bb.upload.protocol=arduino
atmega328bb.upload.maximum_size=32256
atmega328bb.upload.maximum_data_size=2048
atmega328bb.upload.speed=57600
atmega328bb.upload.tool=avrdude

atmega328bb.bootloader.tool=avrdude
atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0xFD
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=atmega/ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.board=AVR_ATMEGA328P
atmega328bb.build.core=arduino
atmega328bb.build.variant=standard

Il va falloir programmer les « fuses » du micro-contrôleur afin qu’il utilise son horloge interne à 8 MHz.
Le montage est identique à celui utilisé au chapitre « Téléchargement du bootloader sur l’ATmega328P » , mais la procédure est légèrement différente :

1. Connecter l’Arduino Uno au PC via un câble USB et selectionner la carte Arduino Uno (Outils/Type de carte/Arduino Uno) et le port USB correspondant
2. Téléverser le croquis ArduinoISP (Fichiers/Exemples/11.ArduinoISP/ArduinoISP ) sur l’Arduino Uno
3. Sélectionner le programmateur « Arduino as ISP  » (Outils/programmateur/Arduino as ISP)
4. Selectionner la carte « ATmega328 8 MHz internal clock » (Outils/Type de carte/ATmega328 8 MHz internal clock)
5. Grave la séquence d’initialisation sur l’ATmega328P (Outils/Graver la séquence d’initialisation)

Il faut ensuite téléverser le programme sur l’ATmega328P. Le montage est identique au chapitre « Téléversement d’un programme sur l’ATmega328P » , mais la procédure est légèrement différente :

1. Selectionner la carte « ATmega328 8 MHz internal clock » (Outils/Type de carte/ATmega328 8 MHz internal clock)
2. Selectionner le port USB sur lequel est connecté le FDTI
3. Téléverser le programme

La consommation est réduite à 5.5 mA LED éteinte.

Mode veille

Comme la plupart des micro-contrôleurs, l’ATmega328P possède différents modes veille.
J’utilise la librairie « SimpleSleep » qui est simple d’utilisation et très efficace. Elle est disponible ici : https://github.com/sleemanj/SimpleSleep

En remplaçant la ligne de code qui attend 5 secondes lorsque la LED est éteinte :

delay(5000);                       // attend 5 secondes

par une mise en veille pendant 5 secondes :

sleep.deeplyFor(5000);             // mode veille pendant 5 secondes

Le gain est spectaculaire sur notre montage minimaliste, la consommation tombe à 4,9 µA (0,0049 mA)…

Autonomie : Notre conception minimaliste offre une autonomie très importante. Par exemple, alimenté par une pile ou batterie de 1000 mAh notre circuit a une autonomie de plusieurs années (1000 mAh / 0.0049 mAh = 204071 h (8503 jours).

Sur l’Arduino Uno, cette mise en veille fait assez peu baisser la consommation. Elle ne tombe qu’à 26,5 mA, et nous voyons donc tout l’intérêt de notre conception minimaliste à base du micro-contrôleur ATmega328P.