Test comparatif de la consommation électrique à vide de diverses cartes Arduino et compatible

Let's do science !

Image d'entête

par skywodd | | Licence (voir pied de page)

Catégories : Tests Dossiers | Mots clefs : Arduino Genuino Consommation électrique Comparatif

Cet article a été modifié pour la dernière fois le


Dans ce dossier, nous allons mettre sur le banc de test une trentaine de cartes Arduino officielles et compatibles pour voir quelles cartes consomment le plus et le moins de courant à vide. Il sera ainsi possible de déterminer les cartes parmi celles testées qui seront les plus adaptées pour une utilisation dans des montages fonctionnant sur batterie.

Sommaire

Bonjour à toutes et à tous !

Il y a quelques semaines, un lecteur m'a contacté pour me demander des conseils par rapport à son montage à base d'Arduino.

Son montage était en soit tout ce qu'il y a de plus classique : des capteurs, un module radio, une carte Arduino et une petite batterie 9 volts pour rendre le tout autonome. Tout aller bien, à un détail près, après seulement une journée de fonctionnement, la batterie était à plat. Le montage en question devait servir à faire des relevés de mesures sur une longue période. À la fois pour des raisons pratiques que financières; il n'était pas envisageable de changer la batterie tous les jours,

Quand on réalise un montage sur batterie, chaque milliampère consommé réduit l'autonomie finale du montage. Il est donc impératif de réduire au strict minimum la consommation électrique du montage au repos. Pour cela, la façon "classique" d'opérer est d'éteindre purement et simplement un maximum de périphériques au repos, comme l'alimentation des capteurs, le module radio et les autres cartes annexes quand cela est possible.

Mais même en coupant l'alimentation de tout ce qui se trouve autour de la carte Arduino, il reste quand même une carte qui consomme du courant : la carte Arduino elle-même. Il est possible sur les cartes Arduino "classiques" de passer le processeur dans un mode basse consommation pour gagner quelques milliampères. Il reste cependant une inconnue de taille : la consommation à vide de la carte.

Combien de milliampères consomme une carte Arduino à vide ? Voilà la question à laquelle cet article va tenter de donner une réponse.

Limitation du test

Ce dossier n'a pas pour objectif de tester toutes les cartes Arduino ou compatibles existantes sur le marché. Cela serait impossible.

Seules les cartes Arduino les plus classiques (et actuellement à ma disposition), à base de microcontrôleurs ATMega328p (Arduino UNO), ATMega2560 (Arduino Mega) et ATMega32U4 (Arduino Leonardo et Micro) ont été testées dans le cadre de cet article.

Il existe bien d'autres cartes compatibles à base de MSP430, STM32 ou encore PIC32 par exemple. Celles-ci ne sont pas incluses dans le test pour des raisons principalement techniques et logistiques. Faire un test comparatif sur des cartes d'architectures processeur différentes serait une erreur. Je me contente donc de comparer ce qui est comparable dans cet article ;)

Provenance des cartes de test

Toutes les cartes de test à l'exception de la Selectronic UNO (plus de détails dans les chapitres plus bas) ont été achetées par moi même sur mes fonds personnels ou ceux du TamiaLab. Que ce soit directement pour cet article ou pour un article antérieur.

Cet article n'est en aucun cas sponsorisé par un tiers, que ce soit directement ou indirectement.

De plus, l'intégralité des tests a été réalisée en respectant une totale objectivité et une méthodologie de test détaillée dans le chapitre suivant.

La méthodologie de test

Tous les fans de MythBuster le savent, la seule différence entre faire n'importe quoi et faire de la science réside dans le fait de documenter l'expérience et les résultats obtenus (source) ;)

Banc de test de consommation électrique

Le banc de test

Tous les tests se déroulent dans des conditions de laboratoire et à une température fixe de ~25°C (un grand merci au passage à Willis Haviland Carrier, l'inventeur de la climatisation – c'était le 114iéme anniversaire de son invention il y a un peu moins de trois semaines).

Chaque carte passe par une série de cinq tests, une première fois avec une alimentation externe de 9 volts sur la prise jack et une seconde fois avec une tension de 5 volts sur le port USB.

  • La tension de 9 volts sur la prise jack (ou sur la broche VIN dans le cas des cartes n'ayant pas de prise jack) a pour but de tester le comportement des cartes dans des conditions d'utilisation sur batterie standard (pile 9 volts, pack de piles, etc.), sur panneau solaire (avec batterie au plomb) ou tout simplement sur alimentation secteur (même si dans ce cas précis, la consommation électrique n'est pas un gros souci).

  • La tension de 5 volts sur le port USB a pour but de tester le comportement des cartes dans des conditions d'utilisation sur batterie USB, sur chargeur secteur USB ou avec des petits panneaux solaires 5 volts.

L'alimentation des cartes durant les tests est réalisée au moyen d'une alimentation de laboratoire Rigol DP832. Cette alimentation a une précision de +/-0,05% + 1mV, avec un bruit inférieur à 80mV (mesuré). L'alimentation sera configurée pour générer les deux tensions continues : 9 volts et 5 volts, avec une limitation de courant de 100mA pour chaque sortie.

Avant chaque série de tests, la tension sur les broches 5V et 3V3 (pour les cartes ayant un régulateur 3.3 volts) sera mesurée avec un oscilloscope Rigol DS1054Z avec une précision fixe de 20mV pour toutes les mesures. Cela permettra d'avoir une vue d'ensemble de la tension sur les broches 5V et 3V3, ainsi que des performances des régulateurs de tension de chaque carte testée.

Pour chaque carte et tension, cinq tests sont réalisés (les codes de tests sont disponibles dans les chapitres suivants) :

  • Le premier test consiste en un simple test de contrôle du bon fonctionnement de la carte. Le but de ce test est simplement de voir si la carte fonctionne et s'il est possible de transférer un programme dans la carte.

  • Le second test consiste en un test de consommation électrique au repos. La carte est programmée pour ne rien faire. Les entrées / sorties seront configurées en sortie pour éviter toutes broches flottantes qui fausseraient la mesure de consommation électrique. Seule la broche D2 est conservée en entrée avec résistance de tirage à l'état haut pour le troisième test.

  • Le troisième test consiste en un test de consommation en mode veille profonde ("power down sleep mode"). Ce test permet de mesure la consommation réelle à vide de la carte quand le microcontrôleur est à l'arrêt. Le code de test comprend un mécanisme pour redémarrer le microcontrôleur via la broche D2 afin de tester le bon fonctionnement de la carte une fois sorti du mode veille.

    N.B. La carte en cours de test devra obligatoirement pouvoir sortir de veille et fonctionner normalement ensuite pour que le test soit validé. Une carte qui se suicide en passant en veille n'a aucun intérêt ;)

  • Le quatrième test consiste en un test de consommation électrique au repos avec la LED broche 13 allumée. Ce test permettra de mesurer la consommation électrique de la LED broche 13 quand celle-ci est disponible.

  • Le cinquième et dernier test consiste en un test de consommation électrique avec un code "lourd" réalisant énormément d'opérations mathématiques diverses. Ce test est purement à but pédagogique. J'ai toujours voulu savoir si la consommation électrique variée (et si oui, dans quelles proportions) quand ont réalise différents types d'opérations avec un microcontrôleur AVR (regroupant les gammes ATMega et ATTiny).

Durant tous les tests, le port série des cartes sera désactivé (broche D1 en sortie et à HIGH) pour éviter d'induire des erreurs de mesure à cause du convertisseur USB-série des cartes.

N.B. Tous les tests sont réalisés deux fois de suite afin de valider les mesures effectuées.

La mesure de la consommation électrique des cartes est réalisée au moyen d'un multimètre de laboratoire de référence Rigol DM3068. Ce multimètre a une précision de 0.010% + 24dig sur la gamme 200µA. Les mesures seront arrondies au 0,01mA (10µA) près par souci de lisibilité.

L'alimentation, l'oscilloscope et le multimètre sont allumés une heure et demie avant la réalisation des tests afin de leur laisser le temps de se stabiliser en température.

Les cartes sur le banc de test

Le jeu de cartes pour ce test comprend 33 cartes Arduino officielles ou compatibles en provenance de divers fournisseurs et fabricants. Certaines cartes sont disponibles en plusieurs exemplaires, d'autres sont disponibles en différentes révisions / versions.

Je n'ai malheureusement pas pu me procurer plusieurs exemplaires de chaque carte pour des raisons de budget. De plus, une grande majorité des cartes testées ont déjà été utilisées dans le cadre d'articles ou projets antérieurs.

Il est donc possible que certaines mesures soient faussées par l'utilisation faite de la carte par le passé. Il n'est pas non plus exclu qu'une carte dans le lot soit défectueuse.

Les cartes Arduino officielles

Photographie d'un lot de cartes Arduino officielles

Cartes Arduino officielles

La liste des cartes Arduino officielles pour ce test contient :

  • Une carte Arduino UNO révision 2 (achetée aux alentours de 2011),

  • Une carte Arduino UNO révision 3,

  • Une carte Arduino UNO révision 3 (de 2016),

  • Une carte Genuino UNO,

  • Une carte Arduino Mega 2560 révision 2,

  • Une carte Genuino Mega 2560,

  • Une carte Arduino Leonardo,

  • Une carte Arduino Nano (dernière version),

  • Une carte Arduino Micro (dernière version).

N.B. Les cartes Arduino Leonardo, Nano et Micro ont été acheté pour cet article et sont donc neuve, tout juste sortie de leur carton.

Ce sont toutes des cartes Arduino officielles, conçues et fabriquées par Arduino.cc ou Arduino.org et achetées chez divers revendeurs de confiance. Ces cartes serviront de référence lors de l'étude des résultats.

Les cartes Arduino compatibles de Sparkfun

Photographie d'un lot de cartes Arduino compatible de Sparkfun

Cartes Arduino compatible de Sparkfun

La liste des cartes Arduino compatibles de Sparkfun pour ce test contient :

  • Une carte Arduino Pro,

  • Une carte Arduino Pro Mini,

  • Une carte compatible Arduino "RedBoard".

N.B. Les cartes Arduino Pro et Pro Mini datent de plusieurs années (alentours 2012 de mémoire). Je n'ai pas pu me procurer d'exemplaires récents de ces cartes. Les résultats devront donc être pris avec des pincettes, car possiblement périmés. Seule la carte RedBoard a été achetée pour cet article.

Les cartes Pro et Pro Mini sont conçues pour des applications portables sur batteries. J'ai donc de grands espoirs concernant ces cartes.

La carte RedBoard est une carte compatible Arduino UNO fabriquée par Sparkfun pour ses coffrets "découvert" et ses tutoriels / projets maison. Le prix est équivalent à une carte Arduino UNO officielle et la qualité est excellente. Je suis donc curieux de voir si cette carte va faire mieux (ou non) qu'une carte Arduino UNO officielle.

Les cartes Arduino compatibles de Seeedstudio

Photographie d'un lot de cartes Arduino compatible de Seeedstudio

Cartes Arduino compatible de Seeedstudio

La liste des cartes Arduino compatibles de Seeedstudio pour ce test contient :

  • Une carte Seeeduino version 2.1,

  • Une carte Seeeduino version 4.2.

N.B. La carte Seeeduino version 4.2 a été acheté pour cet article.

Cela fait de longue année que j'utilise la Seeeduino version 2.1. Cette carte à deux gros avantages :

  • On peut choisir la tension d'alimentation du microcontrôleur avec un simple interrupteur 5V / 3V3.

  • On peut aussi activer ou non le redémarrage automatique de la carte lors de l'ouverture du port série avec un autre interrupteur.

Grâce à ces deux points, la seeeduino est vite devenue ma carte de préférence pour le "data logging" (prise de mesure à intervalle régulier).

Cependant, la version 2.1 ne dispose que d'un connecteur pour une batterie 9 volts et le régulateur de tension consomme une vingtaine de milliampères au repos, ce qui est assez élevé pour une utilisation sur batterie. La version 4.2 au contraire, dispose d'un convertisseur DC/DC pour l'alimentation 5 volts. Cela peut être un gros avantage comme un énorme inconvénient pour la consommation électrique en fonction du convertisseur utilisé.

Les cartes Arduino compatibles de Selectronic

Photographie d'une carte Selectronic UNO (Arduino compatible)

Carte Selectronic UNO

La liste des cartes compatible Arduino pour ce test s'allonge avec la Selectronic UNO. C'est l'invité surprise de ce test et cerise sur le gâteau, c'est une carte française.

Je ne connaissais pas cette carte avant que Thierry Mormentyn, le gérant de la boutique Selectronic me la fasse connaitre sur Twitter. Ayant épuisé mon budget achat pour cet article, j'ai tenté le coup du regard de chien battu dans l'espoir d'obtenir un exemplaire de la carte pour mes tests. Mr Mormentyn a bien voulu jouer le jeu en m'envoyant une carte gracieusement. Je le remercie chaleureusement pour cela :)

Nota Bene

La carte ayant servi pour ce test m'a été offerte par Selectronic, qui produit et commercialise la carte en question. Je vais donc couper court à toute théorie du complot : non, cet article n'est pas sponsorisé. Il n'y a pas non plus le moindre contrat ou partenariat entre le TamiaLab et Selectronic.

La carte a été testée avec la même rigueur que les autres cartes et dans les mêmes conditions. Le lien vers la boutique ci-dessus est de ma propre initiative pour les lecteurs qui n'auraient jamais entendu parler de Selectronic. Il ne s'agit pas d'un lien sponsorisé ou d'un placement de produit.

Pour ceux qui auraient encore des doutes (et je les comprend vu les méthodes de certains collègues blogueurs), j'ai écrit une page dédiée sur le sujet que je vous invite à lire.

Comme vous l'aurez deviné au nom de la carte, c'est une carte conçue en interne par les ingénieurs de Selectronic. Ce qui a attiré mon attention avec cette carte et qui m'invite à en parler un peu plus en détail, c'est la façon dont elle a été conçue : par rétro-ingénierie partielle.

Les ingénieurs de Selectronic ont pris une carte Arduino officielle et le schéma disponible sur le site arduino.cc puis ont vérifié point par point chaque détail (la liste des points de vérification est fournie en PDF dans le lien ci après, ça vaut le coup d'oeil). Ils ont ainsi découvert que la team Arduino ne s'inquiète pas trop de mettre à jour ses schémas publiés sur le site arduino.cc. C'est la première fois que je vois un fabricant aller aussi loin dans l'espoir de faire un clone parfait d'une carte Arduino officielle.

Je suis vraiment impressionné par les efforts fournis dans le but de faire une copie parfaite d'une carte Arduino UNO, de bonne qualité, mais moins cher. J'espère sincèrement que cette carte obtiendra des résultats similaires (voir idéalement meilleurs) qu'une carte Arduino UNO officielle.

Et pour ceux qui se posent la question, oui cela est parfaitement légal de faire un clone d'une carte Arduino tant que la marque et le logo "Arduino" ne sont pas inclus dans le clone. C'est le principe même de l'open source hardware qui permet cela.

N.B. J'ai téléchargé les fichiers de conception sur la page officielle de la carte Arduino UNO pour voir si le schéma a été finalement mis à jour après un an. Sans grande surprise, le schéma disponible en ligne n'est toujours pas à jour, même si entre-temps les cartes Genuino ont fait leurs apparitions. Il semblerait que la team Arduino a encore pas mal de soucis avec le versionnage de ses fichiers.

Les cartes Arduino compatibles de Olimex

Photographie d'un lot de cartes Arduino compatible de Olimex

Cartes Arduino compatible de Olimex

La liste des cartes Arduino compatibles de Olimex pour ce test contient :

  • Une carte Olimexino-328 révision B,

  • Une carte Olimexino-328 révision C,

  • Une carte Olimexino-32u4 révision A.

J'ai vraiment d'énormes espoirs concernant ces cartes.

Par le passé, j'ai toujours associé Olimex avec des produits de grande qualité et entièrement Open Source. À ma connaissance, Olimex est la seule entreprise à avoir poussé l'open source jusqu'à utiliser uniquement des logiciels Open source en interne (avec l'utilisation de Kicad en lieu et place de Eagle par exemple).

Ces cartes sont vendues comme étant "ultra low power" (ultra basse consommation) et avec une conception limitant le bruit lors des mesures analogiques. Chacune de ses cartes dispose d'un chargeur de batterie lithium et d'un connecteur pour une batterie LiPo 1S (3.7 volts). De plus, il est clairement dit sur la fiche produit que les régulateurs de tension de ces cartes ne consomment que quelques microampères sur batterie. Par conséquent, si ces cartes obtiennent de mauvais résultats, je serais vraiment surpris (et déçu).

N.B. La carte Olimexino-328 révision C a été acheté pour cet article. Toutes les cartes fonctionnent avec un quartz de 16MHz sous une tension de 5 volts. Je tiens à préciser ces deux points de détails, car il est possible de changer le quartz et la tension d'alimentation du microcontrôleur sur ces cartes.

Les cartes Arduino compatibles chinoises

Photographie d'un lot de cartes Arduino compatible chinoises

Cartes Arduino compatible chinoises

Et pour finir, je ne pouvais pas faire ce test sans inclure une poignée de cartes chinoises, directement importée de Hong Kong. Je sais que vous êtes nombreux à utiliser ce genre de carte. Je me devais donc de les tester.

J'ai ainsi crédité mon compte Paypal de 35€ avant de faire un tour sur Ebay. J'ai cherché "arduino uno", "arduino nano", "arduino pro mini" et "arduino micro". J'ai ensuite trié les résultats de recherche par prix et acheté les cartes les moins chères (frais de port inclus) que j'ai pu trouver chez différents vendeurs dans l'espoir de voir arriver au moins une carte de chaque type à l'atelier.

Au total, j'ai acheté 14 cartes de 14 vendeurs Ebay différents, tous situés en chine. Cela fait une moyenne de 2.5€ par carte, ce qui est ridiculement faible. Toutes les cartes sont arrivées à destination (ce qui en soit en un vrai miracle) et encore plus fort, toutes les cartes marchent.

La qualité des cartes "UNO" m'a franchement épaté (pour le prix). Pour 3€, on reçoit une carte de qualité correcte (pas extraordinaire, mais pas mauvaise pour autant), un câble USB (de 10cm, certes) et un lot de connecteurs. Je suis assez impressionné. Inutile cependant de vous jeter sur Ebay, ces cartes ont pas mal de défauts majeurs dont je parlerai plus tard. Pour les cartes "Nano" et "Pro mini", le rapport qualité / prix était bien moins intéressant (comprendre : c'est vraiment de la m***e).

Les codes de tests

Pour ceux qui voudraient reproduire les résultats de tests ci-dessous, voici les codes de test que j'ai utilisés :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
/**
 * Code de test 1 : vérification du fonctionnement de la carte.
 * Fait clignoter la LED broche 13 pour tester le bon fonctionnement de la carte.
 */

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
}

void loop() {
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
 * Code de test 2 : mesure de consommation électrique au repos.
 */
 
#if defined(__AVR_ATmega2560__)
#define MAX_PIN_NUM A15
#elif defined(__AVR_ATmega328P__)
#define MAX_PIN_NUM A5
#elif defined(__AVR_ATmega32U4__)
#define MAX_PIN_NUM A5
#endif

void setup() {
  
  // Port série au repos
  pinMode(0, INPUT);
  pinMode(1, OUTPUT);
  digitalWrite(1, HIGH);
  
  // Evite les broches flottantes
  for (byte pin = 3; pin <= MAX_PIN_NUM; pin++) {
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
  }
  
  // En prévision du test 3
  pinMode(2, INPUT_PULLUP);
}

void loop() {
  
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/**
 * Code de test 3 : mesure de consommation électrique en mode "Power Sleep Down".
 */

#if defined(__AVR_ATmega2560__)
#define MAX_PIN_NUM A15
#elif defined(__AVR_ATmega328P__)
#define MAX_PIN_NUM A5
#elif defined(__AVR_ATmega32U4__)
#define MAX_PIN_NUM A5
#endif

// Bibliothéque (fournie avec le compilateur) pour les fonctions de mise en veille
#include <avr/sleep.h>

// Bug fix pour Arduino 1.0.6
#define NOT_AN_INTERRUPT -1

void setup() {

  // Port série au repos
  pinMode(0, INPUT);
  pinMode(1, OUTPUT);
  digitalWrite(1, HIGH);

  // Evite les broches flottantes
  for (byte pin = 3; pin <= MAX_PIN_NUM; pin++) {
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
  }

  // Interruption de sortie de mode sleep (vérif fonctionnement)
  pinMode(2, INPUT_PULLUP);
  // Utilise le mode LOW pour la compatibilité avec les cartes Mega 2560
  attachInterrupt(digitalPinToInterrupt(2), wakeUp, LOW);

  // Mode sleep
  if (digitalRead(2)) {
    sleep_enable();
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    sleep_mode(); 
    sleep_disable();
  }

  // Code vérif fonctionnement post mesure
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
}

void wakeUp() {
  detachInterrupt(digitalPinToInterrupt(2));
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * Code de test 4 : mesure de consommation électrique au repos avec la LED broche 13 allumée.
 */
 
#if defined(__AVR_ATmega2560__)
#define MAX_PIN_NUM A15
#elif defined(__AVR_ATmega328P__)
#define MAX_PIN_NUM A5
#elif defined(__AVR_ATmega32U4__)
#define MAX_PIN_NUM A5
#endif

void setup() {

  // Port série au repos
  pinMode(0, INPUT);
  pinMode(1, OUTPUT);
  digitalWrite(1, HIGH);
  
  // Evite les broches flottantes
  for (byte pin = 3; pin <= MAX_PIN_NUM; pin++) {
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
  }

  // En prévision du test 3
  pinMode(2, INPUT_PULLUP);

  // Test avec LED pin 13 active
  digitalWrite(LED_BUILTIN, HIGH);
}

void loop() {

}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/*
 * Code de test 5 : générateur de fractale de Mandelbrot
 */

/* Includes */
#include <stdint.h>
 
#if defined(__AVR_ATmega2560__)
#define MAX_PIN_NUM A15
#elif defined(__AVR_ATmega328P__)
#define MAX_PIN_NUM A5
#elif defined(__AVR_ATmega32U4__)
#define MAX_PIN_NUM A5
#endif

/* Defines */
#define MAX_ITERATION 142 // Nombre de couleurs
#define SCREEN_X_MAX 320  // 
#define SCREEN_Y_MAX 240  // Taille de l'écran

/**
 * Tableaux de couleurs (142 couleurs, tiré d'un nuanciez HTML trouvé sur le web)
 */
const uint16_t color_table[MAX_ITERATION] = { // HTML color
  0xf7df, 0xff5a, 0x7ff, 0x7ffa, 0xf7ff, 0xf7bb, 0xff38, 0xff59, 0x1f, 0x895c, 
  0xa145, 0xddd0, 0x5cf4, 0x7fe0, 0xd343, 0xfbea, 0x64bd, 0xffdb, 0xd8a7, 0x7ff, 
  0x11, 0x451, 0xbc21, 0xad55, 0x320, 0xbdad, 0x8811, 0x5345, 0xfc60, 0x9999, 
  0x8800, 0xecaf, 0x8df1, 0x49f1, 0x2a69, 0x67a, 0x901a, 0xf8b2, 0x5ff, 0x6b4d, 
  0x1c9f, 0xd48e, 0xb104, 0xffde, 0x2444, 0xf81f, 0xdefb, 0xffdf, 0xfea0, 0xdd24, 
  0x8410, 0x400, 0xafe5, 0xf7fe, 0xfb56, 0xcaeb, 0x4810, 0xfffe, 0xf731, 0xe73f, 
  0xff9e, 0x7fe0, 0xffd9, 0xaedc, 0xf410, 0xe7ff, 0xffda, 0xd69a, 0x9772, 0xfdb8, 
  0xfd0f, 0x2595, 0x867f, 0x839f, 0x7453, 0xb63b, 0xfffc, 0x7e0, 0x3666, 0xff9c, 
  0xf81f, 0x8000, 0x6675, 0x19, 0xbaba, 0x939b, 0x3d8e, 0x7b5d, 0x7d3, 0x4e99, 
  0xc0b0, 0x18ce, 0xf7ff, 0xff3c, 0xff36, 0xfef5, 0x10, 0xffbc, 0x8400, 0x6c64, 
  0xfd20, 0xfa20, 0xdb9a, 0xef55, 0x9fd3, 0xaf7d, 0xdb92, 0xff7a, 0xfed7, 0xcc27, 
  0xfe19, 0xdd1b, 0xb71c, 0x8010, 0xf800, 0xbc71, 0x435c, 0x8a22, 0xfc0e, 0xf52c, 
  0x2c4a, 0xffbd, 0xa285, 0xc618, 0x867d, 0x6ad9, 0x7412, 0xffdf, 0x7ef, 0x4416, 
  0xd5b1, 0x410, 0xddfb, 0xfb08, 0x471a, 0xec1d, 0xd112, 0xf6f6, 0xffff, 0xf7be, 
  0xffe0, 0x9e66
};

/* Setup */
void setup() {
  
  // Port série au repos
  pinMode(0, INPUT);
  pinMode(1, OUTPUT);
  digitalWrite(1, HIGH);
  
  // Evite les broches flottantes
  for (byte pin = 3; pin <= MAX_PIN_NUM; pin++) {
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
  }
  
  // En prévision du test 3
  pinMode(2, INPUT_PULLUP);
}
 
/* Loop() */
void loop() {
  
  // Fenêtre de dessin dans le plan réel/complexe de mandelbrot
  static float x0 = -2.5;
  static float y0 = -1;
  static float x1 = 1;
  static float y1 = 1;

  unsigned long stime = millis();   // Temps avant dessin
   
  //lcd.clear(COLOR_BLACK);           // Écran noir
  draw_mandelbrot(x0, y0, x1, y1); // Dessin d'un figure de mandelbrot
   
  /* Effet de zoom très sommaire et pas du tout proportionné ... */
  x0 += 0.1;
  if(x0 > 1) x0 = -2.5;
  y0 += 0.1;
  if(y0 > 1) y0 = -1;
  x1 -= 0.1;
  if(x1 < -2.5)x1 = 1;
  y1 -= 0.1;
  if(y0 < -1) y1 = 1;
}

/* Fonction de dessin d'un pixel */
void draw_pixel(uint16_t x, uint16_t y, uint16_t color) {
  volatile uint16_t gcc_please_dont_optimize_this = x ^ y;
  gcc_please_dont_optimize_this += color;
  //lcd.drawPixel(x, y, color);
}

/** 
 * Dessine une fractale de Mandelbrot
 */
void draw_mandelbrot(const float x0, const float y0, const float x1, const float y1) { 
  for(uint16_t x = 0; x < SCREEN_X_MAX; ++x) {
    float sx = x * (x1 - x0) / SCREEN_X_MAX + x0;
     
    for(uint16_t y = 0; y < SCREEN_Y_MAX; ++y) {
      float sy = y * (y1 - y0) / SCREEN_Y_MAX + y0;
       
      float z_r = 0, z_i = 0;
      uint16_t i = 0;
 
      do {
        float tmp = z_r * z_r - z_i * z_i + sx;
        z_i = 2 * z_r * z_i + sy;
        z_r = tmp;
        ++i;
      } while((z_r * z_r + z_i * z_i) < 4 && i < MAX_ITERATION);
 
      draw_pixel(x, y, (i == MAX_ITERATION) ? 0x0000 : color_table[i]);
    }
  }
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

La constante LED_BUILTIN (qui vaut 13 par défaut) a dû être remplacée par la valeur 7 lors du test de la carte Olimexino-32U4, car sur cette carte, la LED se trouve sur la broche D7.

Résultat des tests

Données brutes disponibles en téléchargement

Capture d'écran des résultats de mesures du comparatif de cartes Arduino ou compatible

Capture d'écran des résultats de mesures

Pour ceux qui le souhaitent, les données brutes sont disponibles sous forme de tableur Open Document (compatible Libre Office, Excel, etc.) à l'adresse suivante : Tests cartes Arduino.ods.

Edit 15/08/2016: Le lien DropBox ci-dessus est mort (mon compte a été bloqué, merci Dropbox pour la vilaine surprise). Voici une copie Google-Drive à titre temporaire.

Merci de noter que ces données sont publiées sous licence Creative Common BY-SA. Vous êtes donc libre de les redistribuer par tous moyens et sous tous formats, ainsi que de les transformer à condition de préciser la source des données (un lien vers cet article), l'auteur d'origine ("Fabien Batteix, pour le site Carnet du Maker") et les modifications effectuées s'il y en a.

PS Toutes les images des graphiques sont visibles en grande taille en cliquant sur l'image, puis en cliquant sur le lien "Original".

Tensions 5V et 3V3

Començont l'étude des résultats des tests par les graphiques de tension sur les broches 5V et 3V3.

Ces mesures permettent de se faire une idée grossière de la qualité de la régulation des tensions au sein des cartes testées. Avoir une carte basse consommation ne doit pas se faire aux dépens de la régulation des tensions.

Graphique de tension sur la broche 5V

Graphique de tension sur la broche 5V

Sur la broche 5V avec une alimentation 9 volts, toutes les cartes donnent des mesures aux alentours de 5.10 volts. Ce qui est tout à fait respectable. Trois cartes sortent cependant du lot avec une moyenne de 5.28 volts : la seeeduino 4.2 et les deux cartes Olimexino-328. Les convertisseurs DC/DC ont toujours une tendance à être au-dessus de la tension de consigne quand le courant est faible. On reste cependant dans la marge fonctionnelle de la plupart des circuits logiques qui est généralement de +/- 0.5 volts .

Toujours sur la broche 5V, mais avec une alimentation de 5 volts cette fois-ci, les résultats sont totalement différents. Les cartes Arduino officielles et la Selectronic UNO sont dans les alentours de 4.7 et 4.8 volts. Ce qui est là aussi tout à fait acceptable. Les autres cartes compatibles et les cartes UNO chinoises sont dans les alentours de 4.9 volts, à l'exception de cinq cartes chinoises ("Nano" et "Micro") avec une tension assez basse de 4.6 volts. On est encore dans la marge fonctionnelle, mais il ne faudrait pas grand-chose pour que certains capteurs commencent à faire n'importe quoi.

Cette différence entre les diverses cartes chinoises est au passage assez intéressante vu que toutes les cartes tirent la tension 5 volts directement du port USB via un fusible réarmable PTC. On peut donc en déduire que la qualité du fusible joue de manière assez importante sur la tension en sortie avec une alimentation 5 volts par USB.

Pour moi, la conclusion qu'il faut tirer de ces mesures est assez simple : en alimentation par le port USB, la tension sur la broche 5V est peu fiable et dépend fortement de la carte utilisée (officielles ou non).

Les tensions mesurées ne devraient pas poser de problème à l'usage. Mais dans le cadre d'une utilisation avec des capteurs analogiques, le fait de partir du principe que la tension d'alimentation est de 5.0 volts dans le code pour faire ses calculs est une grave erreur. Même avec une alimentation externe de 9 volts, on remarque que la broche 5 volts n'a jamais vraiment à 5 volts. Si l'on souhaite faire des mesures analogiques précises, il faudra faire une mesure de la tension d'alimentation avant de mesurer la tension sur la broche analogique voulue. J'ai justement fait un article sur le sujet récemment.

Graphique de tension sur la broche 3V3

Graphique de tension sur la broche 3V3

Sur la broche 3V3, qu'importe la tension d'alimentation, les résultats sont similaires et autour de 3.4 volts.

Les cartes Olimexino-328 et une carte chinoise "Nano" sortent du lot avec une tension de 3.5 volts à vide, ce qui est un peu élevé, sans pour autant être critique. Pour les cartes Olimexino-328, cela reste quand même étonnant vu que la régulation de la tension 3.3 volts se fait au moyen d'un simple régulateur linéaire de tension et non d'un convertisseur DC/DC. Or, un régulateur linéaire de tension de qualité ne devrait pas dépasser les 3.4 volts, tout au plus.

Ce que l'on remarquera surtout sur le graphique, c'est que la qualité de la régulation de tension des cartes chinoises n'est pas du tout la même pour chacune des cartes testées. Dans mon cas, j'ai reçu des cartes avec des régulateurs de tension de plutôt bonne qualité. Maintenant, cela ne sera pas forcément le cas pour le lot suivant.

Un autre point intéressant que ce graphique met en évidence est l'indisponibilité pure et simple d'une tension régulée de 3.3 volts sur les cartes "Pro" et "Pro Mini".

Les broches 5V et 3V3 sont connectées sur les carte Arduino Pro de sparkfun

Sur les cartes Arduino Pro de Sparkfun (dernière version incluse), les broches 5V et 3V3 sont connectées ensemble.

Cela signifie qu'avec la version 5 volts de la carte, il y a du 5 volts sur les broches 3V3 et 5V. Inversement, avec la version 3.3 volts, il y a du 3.3 volts sur les broches 5V et 3V3. C'est particulièrement idiot et dangereux.

Si vous connectez une shield Arduino utilisant la broche 3V3 pour s'alimenter en 3.3 volts sur une carte Arduino Pro 5 volts, vous vous retrouverez avec une shield HS, grillée par le 5 volts en provenance de la broche 3V3.

PS Ne vous faites pas avoir par le plongeon de la courbe. 3.25 volts est aussi proche de 3.3 volts que les 3.35 volts des autres cartes. Je sais que le choix d'un graphique XY est discutable, mais je n'avais pas vraiment d'autres solutions pour rendre les valeurs "lisibles" graphiquement.

Graphique de bruit sur les broche 5V et 3V3

Graphique de bruit sur les broche 5V et 3V3

Passons maintenant aux mesures de bruit sur les broches 5V et 3V3. J'ai gardé uniquement la valeur la plus grande des deux mesures pour avoir une vue d'ensemble, toutes tensions confondues. De plus, les mesures étant faites avec un oscilloscope pour "voir" le bruit, je ne parlerai que des valeurs qui sortent vraiment du lot.

Toutes les cartes ont donné des résultats similaires entre 80 et 120mV. Seules quatre cartes sortent définitivement du lot : la Seeeduino 4.2, les deux cartes Olimexino-328 et une carte "Nano" chinoises.

La carte Nano chinoise utilise un simple régulateur de tension linéaire. On peut donc facilement imaginer la source du bruit : le régulateur 5 volts de cette carte doit être défectueux ou simplement de moindre qualité. Je pencherai plutôt pour cette seconde hypothèse vu la qualité générale de ces cartes "Nano".

Ce qui me dérange un peu plus c'est le bruit assez conséquent des trois autres cartes. Ces cartes avec ont des convertisseurs DC/DC pour la tension de 5 volts. Un convertisseur DC/DC fonctionne par découpage d'une tension plus élevée. C'est pour cela qu'on appelle ce type d'alimentation des "alimentations à découpage". Le souci c’est que ce genre d'alimentation produit beaucoup de bruit qui doit être filtré efficacement.

Un bruit de 250 ~ 300mV ne pose pas de problème avec de l'électronique purement logique, par contre pour des mesures de tensions analogiques (en provenance de capteurs par exemple), c'est complètement différent. J'ai presque envie de mettre un carton rouge à ces trois cartes rien que pour cela.

Du bruit, un gros WTF dans le schéma et du coil whine !?

Bruit mesuré sur la broche AVCC d'un carte Olimexino-328

Bruit mesuré sur la broche AVCC d'un carte Olimexino-328

Je vais être franc, les cartes Olimexino-328 m'ont très fortement déçue lors des tests. J'en suis même arrivé à me demander si je n'avais pas deux cartes défectueuses.

Ce que vous voyez ci-dessus est une capture d'écran de mon oscilloscope avec la sonde directement placée sur la broche AVCC du microcontrôleur de chacune des deux cartes.

Pour ceux qui ne sont pas très à l'aise avec les microcontrôleurs, la broche AVCC est la broche d'alimentation du convertisseur analogique / numérique. La tension sur cette broche est critique, car c'est cette tension qui sert par défaut de point de référence pour les mesures analogiques. S'il y a du bruit sur cette broche, les mesures seront obligatoirement faussées.

Autant vous dire que j'ai eu un instant de choc en voyant autant de bruit sur la broche AVCC. Et ce bruit ne vient pas de nulle part. Il s'agit du bruit du convertisseur DC/DC. Fait intéressant, entre la révision B et C de la carte, il semblerait que le convertisseur utilise une fréquence de découpage fixe d'un côté et variable de l'autre.

Extrait du schéma de la carte Olimexino-328

Extrait du schéma de la carte Olimexino-328

De plus, en étudiant le schéma de la carte pour comprendre un autre problème décrit plus bas, j'ai remarqué que la broche AREF est directement reliée à AVCC via une résistance de 0 ohms, implémentée sur la carte sous la forme d'un jumper normalement fermé. Cela signifie que si par malheur on tente d'utiliser la broche AREF via le connecteur Arduino, on connecte directement le 5 volts interne de la carte à une référence de tension externe.

Le manuel utilisateur ne précise absolument pas que le jumper R6 doit être coupé avant d'utiliser la broche AREF, sous peine de court-circuiter deux alimentations. De plus, ce jumper n'a aucune raison d'être techniquement. La connexion AVCC / AREF se fait en interne dans le microcontrôleur quand cela est demandé par le code. C'est une erreur de débutant ! Même la documentation Arduino précise qu'il ne faut pas faire cela (c'est pour dire !).

Pour achever d'enfoncer le clou, pendant les tests, j'ai été particulièrement agacé par un sifflement aigu. Vous savez, ce genre de sifflement que font les chargeurs de téléphone portable. Le sifflement en question était particulièrement audible. Il m'a fallu quelques minutes de recherche pour finalement comprendre que la source du sifflement était sous mes yeux. Les deux cartes Olimexino-328 que j'ai testées sont victimes de "Coil whine".

Autant vous dire que cela a bien refroidi ma vision des cartes Olimex. Si un lecteur dispose d'une carte Olimexino-328 et peut confirmer ou infirmer mes mesures et observations, cela serait fort apprécié.

Consommation électrique avec alimentation 9 volts externe

Graphique de consommation électrique avec alimentation 9 volts externe

Graphique de consommation électrique avec alimentation 9 volts externe

Afin de représenter simplement les résultats des mesures, j'ai décidé de faire des graphiques en barres combinés. La partie bleue représente la consommation en veille. La partie orange représente le surplus de courant consommé au repos. La partie jaune correspond au surplus de courant consommé par le code de calcul mathématique. Pour finir, la partie verte correspond au surplus de courant consommé par la LED broche 13.

Tout d'abord, on peut remarquer que toutes les cartes Arduino UNO officielles ainsi que la Selectronic UNO consomment à peu près autant de courant. On se situe dans les 34mA en veille, 42mA au repos. La carte Genuino UNO testée consomme un tout petit peu plus (6mA de plus) que les autres cartes UNO officielles.

Les cartes Arduino Nano officielles, Seeeduino 2.1 et RedBoard s'en sortent plutôt bien avec une consommation d'une dizaine de milliampères en veille et une vingtaine de milliampères au repos.

Les cartes Olimexino-328 ont obtenu des résultats identiques avec 18mA en veille et 28mA au repos. On remarque cependant qu'entre la révision B et C, la consommation des LEDs a grandement diminué. Cela est clairement visible quand on a la carte devant les yeux. Les LEDs de la révision B sont beaucoup plus lumineuses que la version C .

Les cartes chinoises s'en sortent très très bien. Je suis même particulièrement étonné de cela ! De plus, les résultats sont similaires pour chaque lot de cartes testées. Cela est encourageant puisque cela indique qu'il y a une certaine constance, même entre différents fabricants et vendeurs.

Les cartes UNO chinoises consomment environ 8mA en veille et 18mA au repos. Les cartes Nano chinoise consomment environ 6mA en veille et 18mA au repos. Pour finir, les cartes Pro Mini chinoise consomment environ 3mA en veille et 14mA au repos. Il y a de quoi être sérieusement impressionné !

Mais le grand vainqueur dans la catégorie Arduino UNO / Pro / Pro Mini est sans l'ombre d'un doute les cartes Arduino Pro et Arduino Pro mini de Sparkfun. Moins d'un milliampère en veille et environ 12mA au repos. C'est ce que j'appelle de la basse consommation, de la vraie ! Avec une telle consommation, on peut espérer une autonomie de 20 jours en veille avec une simple pile 9 volts de 500mAh.

Dans la catégorie Arduino Mega, les deux cartes officielles testées ont donné des résultats semblables. La version Genuino a là aussi une consommation un poil supérieure à la version pré-Genuino.

Dans la catégorie Arduino Leonardo, les résultats sont très hétérogènes. Il n'y a pas vraiment de tendance, toutes les cartes ont obtenu des résultats différents, même les cartes chinoises.

Je n'ai pas parlé de la carte Seeeduino 4.2 ? Exact. Que dire … La carte doit être défectueuse. Je ne vois que cela pour expliquer une consommation de 68mA en veille, sinon c'est une farce. Le convertisseur DC/DC consomme à lui seul 45mA (voir graphique suivant), soit autant d'une carte Arduino UNO officielle au repos !

PS Si un lecteur dispose d'une carte Seeeduino 4.2, qu'il n'hésite pas à mesurer la consommation à vide de sa carte pour confirmer ou infirmer ma mesure ;)

Consommation électrique avec alimentation 5 volts USB

Graphique de consommation électrique avec alimentation 5 volts USB

Graphique de consommation électrique avec alimentation 5 volts USB

Les résultats en 5 volts sont beaucoup plus "lisses", car dans cette configuration les convertisseurs DC/DC et autres régulateurs de tension 5 volts sont inactifs / contournés.

Les cartes Arduino UNO officielles et la Selectronic UNO obtiennent là aussi des mesures semblables avec une consommation d'environ 30mA en veille et 38mA au repos.

Les cartes Arduino Nano officielles, Seeeduino 2.1 et RedBoard s'en sortent bien avec une consommation d'environ 10mA en veille et 20mA au repos.

La seconde carte Olimexion-328 et toutes les cartes chinoises UNO, Pro Mini et Nano s'en sortent avec des résultats semblables de l'ordre de 7mA en veille et 18mA au repos. Pour je ne sais quelle raison, la première carte Olimexion-328 (révision B ) a une consommation en veille beaucoup plus élevée (7mA de plus environ, cela pourrait être dû à la LED d'alimentation).

En alimentation 5 volts USB, la carte Seeeduino 4.2 obtient des résultats fondamentalement différents et elle se place entre les cartes Arduino UNO officielles et les autres cartes compatibles UNO. En faisant la différence des deux mesures, on se rend vite compte qu'il y a quelques choses d'étranges avec le convertisseur DC/DC de cette carte.

Pour finir, les cartes Arduino Pro et Pro Mini de Sparkfun remportent encore une fois la première et seconde place avec une consommation de moins d'un demi-milliampère en veille. On peut espérer atteindre plus d'un mois d'autonomie avec une simple pile 9 volts.

Pour les cartes Arduino Mega, les deux cartes officielles testées ont donné des résultats similaires. La version Genuino a encore une fois affiché une consommation un poil supérieure à la version pré-Genuino.

Et comme avec le graphique précédent, les cartes Arduino Leonardo ou compatible ont données des résultats divers, différents pour chaque carte.

Ma conclusion personnelle

Quand on fait des montages "basse consommation", le standard de facto est d'avoir une consommation inférieur au milliampère en veille. Pour certains domaines, une consommation de quelques milliampères est acceptable. Dans d'autres domaines, une consommation de plus de 500µA est inenvisageable. Cela est au final toujours une question de rapport autonomie / capacité de batterie.

Parenthése mathématique

Pour calculer l'autonomie d'un circuit, la formule est très simple : autonomie (en heures) = capacité de la batterie (en mAh) / consommation du circuit (en mAh) * 0.7 .

N.B. Le facteur de 0.7 permet de prendre en compte les divers aléas affectant la capacité de la batterie.

D'après les résultats des tests, voici les cartes que je pourrai envisager d'utiliser dans une application basse consommation (par ordre de choix) :

  • Cartes Arduino Pro Mini de Sparkfun (je n'inclus pas la version Pro à cause du souci d'alimentation 5V / 3V3),

  • Cartes Arduino Pro mini chinoises (mais avec diverses restrictions, voir chapitre suivant),

  • Cartes RedBoard,

  • Cartes Arduino UNO chinoises (là aussi avec diverses restrictions),

  • Cartes Arduino Nano officielles ou Seeeduino 2.21.

N.B. Je n'ajoute pas les cartes Nano chinoises dans ce classement pour une raison simple : elles ne sont pas fiables. La qualité des cartes testées est bien trop mauvaise pour être incluses dans le classement.

À part ces cartes, toutes les autres cartes sont à mes yeux incompatibles avec un contexte d'alimentation basse consommation et d'autonomie longue durée. Même les 18mA d'une carte Olimexino-328 sont à mes yeux beaucoup trop élevés pour considérer la carte comme "basse consommation". Maintenant, comme il n'y a pas de norme écrite sur la consommation d'un montage "basse consommation", chacun est libre de faire son business comme il l'entend.

Juste pour l'exemple. Avec une carte Arduino UNO officielle consommant 29mA au repos (meilleur cas), il faudrait une batterie 9 volts de 21 576 mAh (presque 22 ampères heure !) pour faire fonctionner la carte pendant un mois (31 jours en veille). Pour atteindre une telle capacité, il faudrait une batterie lithium d'aéromodélisme ou une batterie au plomb de scooter ou de clôture électrique. Ce n'est pas terrible comme solution.

Dans un sens, ces résultats ne sont pas étonnants, les cartes Arduino officielles et une bonne partie des cartes compatibles n'ont tout simplement jamais été conçues pour faire de la basse consommation. Mais en même temps, vu l'engouement pour l'internet des objets, la domotique et le DIY, je suis étonné de voir que l'aspect autonomie sur batterie, soit autant négligé.

Si demain un lecteur venait me voir en me disant : "j'ai besoin d'un montage compatible Arduino qui peut survivre un an sur une simple pile 9 volts du commerce", je serais bien embêté. Un microcontrôleur ATMega328p (au coeur des cartes Arduino UNO) peut fonctionner plusieurs années sur une simple pile CR2032. Seulement, la consommation de ce qui l'entoure fait toute la différence et manifestement, il reste encore pas mal de travail à faire dans ce domaine.

Un bon début serait d'avoir un jumper pour déconnecter la LED d'alimentation et la LED broche 13. Durant mes expérimentations, je me suis rendu compte que beaucoup de cartes consomment entre 2mA et 4mA simplement pour allumer une LED que personne ne regarde (ou utilise) la plupart du temps.

Bonus : Toutes les cartes ne se valent pas

Durant les tests, j'ai découvert pas mal de choses sur les cartes testées. Et une chose est sûre : toutes les cartes ne se valent pas. Pour faire simple : quand on paye une carte 3€, il ne faut pas s'attendre à une qualité digne d'une carte à 20€.

Les cartes Arduino Nano chinoises par exemple, celles-ci étaient d'une qualité déplorable. La qualité générale du PCB n'inspirait pas confiance, les composants non plus. Une des cartes a manifestement un régulateur de tension défectueux et une autre a une LED coupée en deux. Cela prouve encore une fois qu'il n'y a aucun contrôle qualité sérieux sur ces cartes chinoises. En même temps, à moins de 3€ la carte, il faut s'en douter.

Les cartes chinoises "UNO", "Pro Mini" et "Pro Micro" étaient de bien meilleure qualité, mais pas extraordinaire pour autant.

Seulement voilà, les cartes Arduino Pro Micro (chinoises ou officielles) n'ont pas de LED sur la broche 13, ce qui m'a posé pas mal de soucis durant les tests. C'est le genre de détail bête que j'aurai aimé connaitre avant de perdre 10 minutes à comprendre pourquoi la LED broche 13 ne s'allumait pas.

Pour les cartes Arduino Pro Mini chinoises, bien que de bonne facture en apparence, celles-ci ont un PCB de 0.6mm d'épaisseur. Les concepteurs de ces cartes ont manifestement voulu réduire les coûts de production en réduisant l'épaisseur du PCB de moitié. Conséquence : les cartes Pro Mini chinoises sont très intéressantes pour des projets "jetables", mais pour de vrais projets à long terme, je ne leurs ferais absolument pas confiance. Le PCB se plie beaucoup trop facilement, les soudures sont limites et le vernis au-dessus de la couche de cuivre n'a pas l'air très épais.

N.B. Le connecteur FTDI pour la programmation des cartes Arduino Pro Mini chinoise est inversé par rapport à la version originale de Sparkfun. Vous êtes prévenu ;)

Plus embêtant selon moi, toutes les cartes chinoises testées utilisées un chipset CH430 en tant que convertisseur USB-série. Celui-ci fonctionne plutôt bien à un détail près : tous les CH430 ont le même numéro de série.

Si vous branchez une carte, débranchez, puis branchez une autre, l'ordinateur croira que vous avez branché la même carte deux fois de suite. Dans mon cas, cela était plutôt pratique, car cela me permettait d'enchainer les tests sans changer de port série. Cependant, dans le cadre d'un projet sans fil avec un émetteur et un (ou plusieurs) récepteur(s), cela serait vite un problème de ne pas pouvoir connecter deux cartes (ou plus) à un même PC en même temps.

Autre problème des chipsets CH430, il n'y a pas de broches d'indicateurs RX/TX. En général, les convertisseurs USB-série ont deux broches dédiées sur lesquelles on vient câbler deux LEDs faisant office d'indicateur d'activité sur le port série. Avec les chipsets CH430, les concepteurs des cartes chinoises ont dû câbler les LEDs directement sur les broches du port série. C'est moche, très moche. Suivant la vitesse du port série et les données qui y transite, les LEDs sont tout simplement impossible à voir, car elles s'allument seulement quand un bit à "0" est transmit. Je ne parle même pas des possibles effets de bords en fonction des modules série que l'on pourrait vouloir utiliser, comme des modules GPS ou des afficheurs séries par exemple.

Personnellement, j'ai l'intime conviction que les chipsets CH430 sont de simples microcontrôleurs avec un port USB (8051 ou équivalent), reprogrammé et vendu comme des convertisseurs USB-série. C'est exactement ce que fait Microchip avec ses MCP2200 qui ne sont en fait que des microcontrôleurs PIC18F programmés en usine. Cela marche parfaitement à des vitesses "standard", mais dès que l'on sort des vitesses standards ou que l’on augmente la vitesse, ça ne marche plus ou très mal.

On peut comprendre ou détester la façon de faire de FTDI avec les FT232R, mais avec un FT232, de 300 bps à 3 000 000 bps, ça marche. C'est l'avantage d'avoir un "vrai" convertisseur USB-série, basé sur un circuit logique dédié, pas juste un microcontrôleur reprogrammé.

Dernier point important et pas des moindres : les cartes à base d'ATMega32U4 (cartes Arduino Leonardo, Micro et Pro Micro) ne peuvent pas passer mode veille sans se suicider.

Si vous passer une carte Arduino Leonardo, Micro, Pro Micro ou n'importe quelle carte à base d'ATMega32U4 en mode veille, vous ne pourrez plus la reprogrammer par la suite.

Pourquoi ? C'est tout bête : une fois la carte en veille, le port USB s'éteint et il devient impossible de relancer le bootloader pour reprogrammer la carte.

Pour être précis, cela est dû au fait qu'un petit bout de code inclus dans chaque programme utilisateur par le framework Arduino doit pouvoir s'exécuter via un ordre en provenance du port USB pour redémarrer la carte et lancer le bootloader. Si la carte est plantée au démarrage ou que le port USB est éteint à cause de la mise en veille, c'est mort.

N.B. Même après être sorti de veille, le port USB reste inactif, car le PC aura entre temps détecté une erreur en provenance du périphérique (qui ne répondait plus) et aura bloqué les communications avec la carte.

1
2
3
4
5
6
7
// Mode sleep
if (digitalRead(2) == HIGH) {
    sleep_enable();
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    sleep_mode(); 
    sleep_disable();
}

Pour contourner ce problème et faire mes tests, j'ai été obligé d'inclure dans mon code un système me permettant d'empêcher la mise en veille quand je souhaite reprogrammer la carte.

Ainsi, si la broche D2 est à LOW, le code de mise en veille ne s'exécute pas et la carte reste active avec le port USB fonctionnel. Je peux ainsi reprogrammer la carte avec le code de test suivant.

Si vous oubliez de prévoir ce genre de sécurité dans vos programmes pour Arduino Leonardo et assimilé, vous vous retrouverez très vite avec des cartes inutilisables. Dans ce cas, seul un programmateur de microcontrôleur AVR pourrait vous sauver.

Annexe : What the fuck Olimex

PS Chapitre coup de gueule, mais bon à lire.

J'ai quelque peu perdu mon calme en tentant de comprendre pourquoi diable la LED broche 13 s'est retrouvée sur la broche D7 sur la carte Olimexino-32U4 (ou D9 vu qu'il y a deux LEDs sur cette carte, mais aucune sur D13).

Au final, pour les curieux, la LED a migré sur la broche D7, car les broches D2, D3 et D13 sont maintenues à une tension de 3.3 volts par une résistance de tirage pour le port UEXT (un port d'extension maison sauce Olimex). Il n'était donc pas possible d'avoir une LED sur ces broches sous peine qu'elles restent constamment allumées.

Le même style de résistances de tirage cachées existe sur les cartes Olimexino-328 au niveau des broches A4, A5, D11 et D7 (par défaut, D10 si on change un jumper), toujours pour le port UEXT. Ça va même plus loin puisque sur les cartes Olimexino-328 il y a une LED sur la broche D13 et D9. En plus d'y avoir un bouton câblé par défaut sur la broche D2.

Je n'ai rien contre ces "fonctionnalités" additionnelles, elles peuvent être pratiques dans certains cas. De même, qu'il y ait un connecteur d'extension pour faciliter l'utilisation de modules tout-prêt, soit. Mais si pour utiliser une broche il faut défaire trois jumpers par ci, deux jumpers par là, bonjour le casse-tête. De plus, la lecture des schémas est pour ainsi dire obligatoire afin de comprendre le fonctionnement réel de ces cartes. Le manuel utilisateur n'est pour ainsi dire d'aucune utilité.

Mais tout ceci n'est pas le sujet de ce chapitre, non, le vrai sujet de ce chapitre c'est la consommation en mode batterie des cartes Olimexino-328.

La fiche produit annonce que le régulateur de tension (3.3 volts) a une consommation de quelques microampères en mode batterie. J'ai donc voulu vérifier cela.

J'ai alimenté la carte avec une tension de 3.7 volts sur le connecteur de batterie pour simuler l'alimentation du montage via une batterie lithium compatible (LiPo 1S).

J'ai ainsi obtenu une tension de 3.40 volts sur la broche 3V3 et rien sur la broche 5V. Jusque là, tout va bien, avec une batterie de 3.7 volts, il n'est possible que d'avoir dû 3.3 volts.

PS Non, il n'est pas possible d'utiliser une batterie LiPo 2S pour avoir du 5 volts.

J'ai ensuite mesuré la consommation de la carte, seulement 3µA ! Jackpot ! Ou pas.

En voulant sortir la carte de veille (rappel : si la carte ne sort pas de veille, le test est raté), je me suis rendu compte que le microcontrôleur n'était en réalité pas alimenté. Pas de LED d'alimentation, pas de signe de vie … étrange.

J'ai donc remis la tête dans le schéma de la carte et j'ai vite compris qu'il fallait placer l'interrupteur d'alimentation sur la position 3V3 pour que la carte fonctionne sur batterie. J'aurai bien aimé que le manuel précise ce détail quelque peu intéressant. Car oui, la carte Olimexino-328 n'est utilisable en mode batterie que si l'alimentation du microcontrôleur est en mode 3.3 volts. Cela signifie que si votre montage utilise des capteurs alimentés en 5 volts, vous pouvez passer votre chemin.

Mais ce n'est pas le pire, le régulateur 3.3 volts consomme effectivement 3µA à vide. La fiche produit ne ment donc pas, mais cela ne veut pas dire que la carte consomme 3µA à vide, nuance. En mode batterie, avec le microcontrôleur en veille, j'ai mesuré une consommation de 8.07mA. Toutes les petites résistances de tirage et autres fonctionnalités bonus cités ci-dessus consomment du courant, surprise.

J'ai toujours l'espoir d'avoir eu la malchance d'être tombé sur deux cartes défectueuses. Parce qu’entre nous, j'ai un peu l'impression d'être pris pour un pigeon en relisant les merveilleuses fonctionnalités des cartes Olimexino-328.

Conclusion

Ce dossier est désormais terminé.

Si ce dossier vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.