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 :

Prise USB (5 V)
Connecteur jack (7-12 V)
Broche VIN de l’Arduino (7-12 V)
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.

Alimentation	LED éteinte	LED allumée
5 V sur broche « 5V »	41,0 mA	44,5 mA
12 V sur broche « VIN »	51,2 mA	55,5 mA

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.

Ligne liaison SPI	Broche Arduino Uno	Broche ATmega328P
SCLK	13	19
MISO	12	18
MOSI	11	17
RESET	10	1

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

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
Téléverser le croquis ArduinoISP (Fichiers/Exemples/11.ArduinoISP/ArduinoISP ) sur l’Arduino Uno
Sélectionner le programmateur « Arduino as ISP » (Outils/programmateur/Arduino as ISP)
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 :

Broche FTDI	Broche ATmega328P
TX	RX (broche 2)
RX	TX (broche 3)
DTR	RESET (via capacité de 100nF relié broche 1)

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 :

Sélectionner la carte « Arduino Uno » (Outils/Type de carte/Arduino Uno)
Sélectionner le port USB sur lequel est connecté le FDTI
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 :

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
Téléverser le croquis ArduinoISP (Fichiers/Exemples/11.ArduinoISP/ArduinoISP ) sur l’Arduino Uno
Sélectionner le programmateur « Arduino as ISP » (Outils/programmateur/Arduino as ISP)
Selectionner la carte « ATmega328 8 MHz internal clock » (Outils/Type de carte/ATmega328 8 MHz internal clock)
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 :

Selectionner la carte « ATmega328 8 MHz internal clock » (Outils/Type de carte/ATmega328 8 MHz internal clock)
Selectionner le port USB sur lequel est connecté le FDTI
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.

Bonjour,
c’est bon, je suis arrivé au bout avec le FTDI.
Si vous le pouvez, supprimez mes premiers posts, voici un résumé de mes difficultés.
Poste de travail : Win 10 Famille – 64 bits
IDE Arduino : 1.8.13
J’ai utilisé une carte Arduino Uno Gotronic pour charger le bootloader
Puce cible : Atmega328P, comme dans le tuto.
FTDI/Usb converter : le modèle de chez Gotronic :
https://www.gotronic.fr/art-convertisseur-usb-serie-ftdi-gt1125-26140.htm

La gravure du bootlaoder via l’Uno est ok.
J’ai juste un doute sur la ligne à décommenter dans le prog ArduinoISP :
// Uncomment following line to use the old Uno style wiring
// (using pin 11, 12 and 13 instead of the SPI header) on Leonardo, Due…
#define USE_OLD_STYLE_WIRING

Le problème venait du FTDI. Contrairement à ce qu’annonce le site Gotronic, et je vais leur indiquer,
seul une partie des drivers s’installe automatiquement par Win 10.
Dans le gestionnaire de périphérique windows, je voyais bien mon FTDI comme device USB avec les bons drivers décrit dans La doc de ftdichip : https://ftdichip.com/wp-content/uploads/2020/08/AN_396-FTDI-Drivers-Installation-Guide-for-Windows-10.pdf
mais par contre je voyais aussi le FTDI comme autre périphérique non reconnu. Ce qui manquait c’est le mapping sur le port COM. D’où le grisé dans l’IDE Arduino.
Selon la doc de ftdichip , la pile de drivers COM (en bleu dans le schéma page 3) manquait.
J’ai téléchargé les drivers adéquats à ma version de Windows : ttps://ftdichip.com/drivers/vcp-drivers/
et ensuite sur clic droit sur le périphérique USB non reconnu, j’ai installé manuellement les drivers en indiquant le chemin ou je les avaient décompressés.
Il faut finalement rebooter le PC pour que tout soit ok (j’ai essayé ça ne marche pas sinon 🙂 )
et alors le port COM apparaît dans l’IDE Arduino et le téléversement est ok, même plusieurs fois.
Une remarque : sur une de mes puces, j’avais téléversé le prog via le Uno. Celle-là ne fonctionne pas avec le FTDI. Il y a une erreur de sync 0xe8 avrdude. Je vais devoir la flasher de nouveau.
Une autre puce qui n’avait reçu que le bootloader, fonctionne correctement par contre.

Donc, le tuto est ok, je vais poursuivre, car mon idée est d’avoir la basse consommation indiquée.
Je suis tombé sur un piège au niveau du FTDI, que je vais signalé au vendeur, au cas où.

Merci.

Répondre

(11 commentaires)

COUËTA Jotian dit :

8 février 2021 à 13h21

Bonjour
j’ai un problème à partir de « Utilisation de l’oscillateur interne » , lorsque je copie le texte supplémentaires dans le fichier « boards.txt », après avoir redémarrer mon IDE, je ne trouve pas le fameux « ATmega328 8 MHz internal clock » dans le menue « Type de carte ». Pouvez-vous m’aidez Svp
Merci.

Répondre
1. Tutoduino dit :
  
  12 février 2021 à 14h37
  
  Bonjour,
  Mon tuto a été réalisé sur Linux, je viens de vérifier sur Windows 10 et cela fonctionne parfaitement également.
  Il faut bien entendu modifier les propriétés du fichier C:\Program Files (x86)\Arduino\hardware\arduino\avr\boards.txt pour ajouter les droits en écriture à l’utilisateur
  
  Et ensuite après avoir relancer l’IDE, « ATmega328 8 MHz internal clock » apparait bien dans la liste des cartes
  Test réalisé avec le dernier IDE 1.8.13 sur Windows 10.
  
  Répondre
Didier dit :

11 février 2021 à 22h59

Bonjour, très intéressant ce tuto. Du coup je m’y suis lancé !
J’ai , en théorie, téléchargé le bootloader sur l’Atmega.
Mais ensuite quand je veux télécharger le prog via le FTDI, l’Atmega n’est pas reconnu comme une UNO. Aucun port USB n’est sélectionnable. J’ai du louper un truc mais je ne vois pas.
J’utilise l’IDE sous Win 10.

Répondre
1. Tutoduino dit :
  
  12 février 2021 à 14h11
  
  Avez-vous bien ajouté la capacité de 100 nF entre la broche 1 de l’ATmega328P et la broche DTR du FTDI ainsi que la résistance de 10 k entre la broche 1 de l’ATmega328P et le 5V ?
  
  Répondre
  1. Didier dit :
    
    12 février 2021 à 22h03
    
    Bonjour, oui il y a bien le condo et la resistance.
    J’ai l’IDE en version 1.8.13
    J’ai regardé le contenu du prog ArduinoISP.
    J’ai du décommenter une ligne pour que SPI soit actif sur les pins 11 à 13 :
    // Uncomment following line to use the old Uno style wiring
    // (using pin 11, 12 and 13 instead of the SPI header) on Leonardo, Due…
    #define USE_OLD_STYLE_WIRING
    
    Ensuite j’ai ajouté des LED qui permettent d’avoir quelques infos lors du flash du bootloader :
    // Put an LED (with resistor) on the following pins:
    // 9: Heartbeat – shows the programmer is running
    // 8: Error – Lights up if something goes wrong (use red if that makes sense)
    // 7: Programming – In communication with the slave
    
    Et lorsque je lance la gravure de la séquence, la LED error s’allume.
    Il y a un souci qq part mais il reste à découvrir …. 🙂
    Je continue de chercher…
    
    Répondre
    1. Didier dit :
      
      13 février 2021 à 11h22
      
      Suite de la recherche : j’ai téléversé le programme LED13 sur l’Atmega328 via le UNO est c’est ok.
      Ca a fonctionné une première fois. Par contre la seconde fois j’ai le message :
      avrdude: Yikes! Invalid device signature.
      Double check connections and try again, or use -F to override
      this check.
      
      L’Atmega328 ne doit plus être reconnu en tant que Uno par l’IDE.
      
      Répondre
      1. Didier dit :
        
        13 février 2021 à 17h44
        
        Bon, le problème reste sur le FTDI/USB converter. Peut-être un pb de driver. Le port reste grisé dans l’IDE Arduino. Pour windows le driver est à jour, ce n’est peut-être pas le cas…
        Le Device est fourni sans driver nécessaire.
Didier dit :

14 février 2021 à 11h28

Bonjour,
c’est bon, je suis arrivé au bout avec le FTDI.
Si vous le pouvez, supprimez mes premiers posts, voici un résumé de mes difficultés.
Poste de travail : Win 10 Famille – 64 bits
IDE Arduino : 1.8.13
J’ai utilisé une carte Arduino Uno Gotronic pour charger le bootloader
Puce cible : Atmega328P, comme dans le tuto.
FTDI/Usb converter : le modèle de chez Gotronic :
https://www.gotronic.fr/art-convertisseur-usb-serie-ftdi-gt1125-26140.htm

La gravure du bootlaoder via l’Uno est ok.
J’ai juste un doute sur la ligne à décommenter dans le prog ArduinoISP :
// Uncomment following line to use the old Uno style wiring
// (using pin 11, 12 and 13 instead of the SPI header) on Leonardo, Due…
#define USE_OLD_STYLE_WIRING

Le problème venait du FTDI. Contrairement à ce qu’annonce le site Gotronic, et je vais leur indiquer,
seul une partie des drivers s’installe automatiquement par Win 10.
Dans le gestionnaire de périphérique windows, je voyais bien mon FTDI comme device USB avec les bons drivers décrit dans La doc de ftdichip : https://ftdichip.com/wp-content/uploads/2020/08/AN_396-FTDI-Drivers-Installation-Guide-for-Windows-10.pdf
mais par contre je voyais aussi le FTDI comme autre périphérique non reconnu. Ce qui manquait c’est le mapping sur le port COM. D’où le grisé dans l’IDE Arduino.
Selon la doc de ftdichip , la pile de drivers COM (en bleu dans le schéma page 3) manquait.
J’ai téléchargé les drivers adéquats à ma version de Windows : ttps://ftdichip.com/drivers/vcp-drivers/
et ensuite sur clic droit sur le périphérique USB non reconnu, j’ai installé manuellement les drivers en indiquant le chemin ou je les avaient décompressés.
Il faut finalement rebooter le PC pour que tout soit ok (j’ai essayé ça ne marche pas sinon 🙂 )
et alors le port COM apparaît dans l’IDE Arduino et le téléversement est ok, même plusieurs fois.
Une remarque : sur une de mes puces, j’avais téléversé le prog via le Uno. Celle-là ne fonctionne pas avec le FTDI. Il y a une erreur de sync 0xe8 avrdude. Je vais devoir la flasher de nouveau.
Une autre puce qui n’avait reçu que le bootloader, fonctionne correctement par contre.

Donc, le tuto est ok, je vais poursuivre, car mon idée est d’avoir la basse consommation indiquée.
Je suis tombé sur un piège au niveau du FTDI, que je vais signalé au vendeur, au cas où.

Merci.

Répondre
1. Tutoduino dit :
  
  14 février 2021 à 11h35
  
  Parfait, merci pour les explications !
  J’ai rajouté ces informations dans le tuto pour aider les personnes qui rencontreraient le même problème.
  
  Répondre
COUËTA Jotian dit :

22 février 2021 à 12h19

Oui effectivement, il faut bien avoir les droit pour modifier le fichier, mais voila j’ai beau cherché je ne trouve pas cette accès même avec l’exemple que vous m’avez fait.

Répondre
COUËTA Jotian dit :

22 février 2021 à 12h40

Alors, j’ai trouvé la solution :
il faut correctement ajuster le texte supplémentaire que l’on doit ajouter a fichier board.txt et être bien évidement en administrateur. Quand je dis bien ajuster CAD que le ficher se présente d’une manière non arranger, il ne suffit pas de bêtement coller les lignes supplémentaires, il faut que les ligne soit correctement mise comme dans les programmes arduino…. j’aurais du mal a mieux expliquer ce que je veut dire sans image.

Répondre