Parmi les cartes Arduino et compatibles les plus usuelles, on a les cas de figure suivants :

1. Les cartes Arduino dont le microcontrôleur est à cœur AVR (Uno, Nano, Mega…) ont un CAN à 10 bits avec une tension de pleine échelle nominale V_max = 5 V (c'est la valeur du potentiel V_DD de la carte).
Donc par défaut, le quantum de CAN vaut q = 5/1024 ≈ 4,9 mV.
2. Les modules ESP8266 ont un CAN à 10 bits avec une tension de pleine échelle V_max = 1,1 V. Toutefois, la plupart des cartes de développement qui embarquent ce module (notamment la SBC‑NodeMCU de Joy‑It – cf. chap. C1‑III ) intègrent un pont diviseur de tension pour porter la pleine échelle de la tension d'entrée à 3,3 V (le potentiel V_DD de la carte).
Donc par défaut, sur une telle carte, le quantum de CAN vaut q = 3,3/1024 ≈ 3,2 mV.
3. Les cartes Arduino dont le microcontrôleur est à cœur ARM (Due, Zero…), ou encore les carte à module ESP32 (comme la NodeMCU‑ESP32 de Joy‑It – cf. chap. C1‑III ), ont typiquement un CAN à 12 bits avec une tension de pleine échelle V_max = 3,3 V (c'est la valeur du potentiel V_DD de la carte).
Donc par défaut, le quantum de la conversion vaut q = 3,3/4096 ≈ 0,8 mV.

Dans la pratique, on constate les qualités et défauts suivants de CAN intégrés aux microcontrôleurs des cartes de développement usuelles.

1. Sur les cartes Arduino, on a aucun défaut macroscopique : l'unicité, la linéarité et le gain sont très satisfaisants. L'erreur relative entre les mesures et les valeurs théoriques est presque toujours inférieure à 0,5 % – cf. le graphique ci‑contre pour une carte Arduino Uno où les mesures sont quasiment confondus les valeurs théoriques (voir le sujet de TP P2‑1  pour le protocole d'expérimentation).

Toutefois, on peut observer un défaut microscopique en bas de l'échelle de conversion : un décalage d'origine positif d'environ 0,01 V à 0,015 V. Il en résulte que les marches de la fonction de transfert réelle se trouvent en dessous de celles de la fonction de transfert théorique, et causent un décalage d'environ −2 sur la valeur de N_s (cf. le graphique ci‑contre, toujours pour une carte Arduino Uno ; il correspond à un très fort grossissement du graphique précédent).
Ce défaut microscopique diminue progressivement sur la première moitié de la pleine échelle de v_e. Il peut être partiellement compensé par une expression corrective dans le programme utilisateur.

2. Sur une carte à module ESP8266, l'unicité et la linéarité sont satisfaisants. En revanche, on a deux défauts macroscopiques (cf. le graphique ci‑contre pour une carte SBC‑NodeMCU de Joy‑It) :
• un gain excessif qui s'accompagne d'une troncature en haut de l'échelle (avec la particularité que la valeur N_max vaut 1024 et non pas 1023) ;
• un décalage d'origine négatif d'environ −0,05 V qui se traduit en bas de l'échelle par une valeur minimale de N_s environ égale à 15 et non pas 0.
Ces deux défauts macroscopiques que sont principalement dus aux incertitudes impondérables sur les valeurs ohmiques effectives des résistors qui forment le pont diviseur de tension qui permet de porter la tension de pleine échelle du CAN à 3,3 V (cf. supra ). S'ils diffèrent en amplitude d'une carte à l'autre, ces défauts restent néanmoins déterministes et sont faciles à compenser au cas par cas, avec une expression corrective dans le programme utilisateur.
Par ailleurs, une étude approfondie des marches en bas d'échelle du CAN, comme celle effectuée supra pour la carte Arduino Uno permet de mettre en évidence des défauts microscopiques de régularité voire de monotonie.

3. Sur une carte à module ESP32, l'unicité, la linéarité ne sont pas satisfaisants et on observe également une troncature en haut de l'échelle. Avec de tels défauts macroscopiques importants, il est difficile d'évaluer l'erreur de gain (cf. le graphique ci‑contre pour une carte NodeMCU‑ESP32 de Joy‑It).
• Le défaut d'unicité étant stochastique, il ne peut être compensé que par la répétition d'une série de conversion et un calcul de moyenne, ce qui se fait au détriment du temps de cycle du programme utilisateur. Il est toutefois possible de diminuer significativement l'étendue des variations de N_s en ajoutant un condensateur de capacité 100 nF entre la broche GND et celle de l'entrée analogique utilisée.
• Quant au défaut de linéarité, il ne correspond à aucune fonction remarquable, aussi est‑il très difficile à compenser (cf. la complexité de la solution proposée par le constructeur Espressif ). Toutefois, ce défaut diminue fortement si on accepte de réduire la tension de pleine échelle en recourant à un facteur d'atténuation (cf. la documentation suivante  et ce fil de discussion ).
Il faut également savoir que la fonction de lecture analogique analogReadMilliVolts (cf. infra ) peut donner des résultats étonnamment stables et précis (avec une erreur relative d'environ 1 % entre 0,6 et 3 V). Néanmoins, pour une mise en œuvre nécessitant une précision élevée, il est préférable de recourir à un module CAN externe, comme par exemple un ADS1115   (16 bits, technologie sigma‑delta, liaison I²C), disponible sur le marché en une grande variété de modules prêt à l'emploi, par exemple celui‑ci .

Considérons le montage académique en figure ci‑contre où le curseur d'un potentiomètre est relié à la broche A0 du port d'entrée analogique d'une carte Arduino Uno.

• Dans le cadre d'une simulation sur Tinkercad, on peut considérer que la tension de référence à laquelle le potentiomètre est alimenté vaut bien V_max  = 5 V.
• On rappelle par ailleurs qu'avec le CAN 10 bits du microcontrôleur Atmel 328P embarqué sur la carte, on a N_max  = 1023.

À partir de la valeur du nombre N_s retournée par l'appel de la fonction analogRead(A0), il est impossible de déterminer la valeur exacte de la tension d'entrée v_e sur la broche A0 qui a généré ce nombre.

En effet, v_e peut se situer partout sur la marche dont la « hauteur » est donnée par N_s. On prend donc « arbitrairement » le point milieu de la marche, situé à son intersection avec la droite d'équation N_s = v_e / q. On obtient alors tout simplement la formule de conversion réciproque :

v_e = N_s . q

Sur ce principe, le programme ci‑dessous code l'affichage toutes les secondes sur le moniteur série de la valeur supposée de la tension d'entrée v_e (variable inputVoltage) avec une résolution à 3 décimales (cf. la ligne nº 12) :

const int POTENTIOMETER_PIN = A0;
const float QUANTUM = 5.0 / 1024; // volts

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  float inputVoltage = analogRead(POTENTIOMETER_PIN) * QUANTUM;
  Serial.println(inputVoltage, 3);
  delay(1000);
}  

Parmi les cartes Arduino et compatibles les plus usuelles, on peut citer les deux cas suivants :

1. Les deux CNA d'une carte Arduino Due (cf. chap. C1‑III ) génèrent une excursion de v_s comprise seulement entre V_min = 0,55 V et V_max = 2,75 V et ont une résolution maximale sur 12 bits.
Donc par défaut, sur une telle carte, le quantum de CNA vaut q = 2,2/4095 ≈ 0,54 mV.
2. Les deux CNA d'une carte à module ESP32 (comme la NodeMCU‑ESP32 de Joy‑It – cf. chap. C1‑III ) génèrent une excursion de v_s comprise entre V_min = 0,1 V et V_max = 3,2 V et ont une résolution maximale sur 8 bits seulement.
Donc par défaut, sur une telle carte, le quantum de CNA vaut q = 3,1/255 ≈ 12 mV.

Les deux montages académiques proposés ci‑après avec une carte Arduino Uno proposés ci‑après peuvent être testés dans l'environnement Tinkercad.

1. Le montage représenté ci‑dessous d'un variateur de luminosité d'une led est constitué :

• d'une led dont l'anode est reliée (via une résistance de limitation de courant) à la broche PWM 3 du port numérique de la carte ;
• d'un potentiomètre relié à la broche A0 du port analogique de la carte.
Ici, le paramètre de pilotage est la luminosité de la led, que l'on peut directement exprimer comme un nombre compris entre 0 et 255 pour faciliter le codage. Pour expliciter le choix, on peut déclarer une variable entière nommée brightness, calculée par mise à l'échelle avec la valeur lue sur le potentiomètre, comme dans le programme ci‑dessous (cf. la ligne nº 11) :

const int8_t POTENTIOMETER_PIN = A0;  
const int8_t LED_PIN           = 3;

void setup()
{
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  int16_t potentiometerValue = analogRead(POTENTIOMETER_PIN);
  uint8_t brightness = map(potentiometerValue, 0, 1023, 0, 255);
  analogWrite(LED_PIN, brightness);
  delay(10); // for a fluid Tinkercad simulation
}  

2. Le montage représenté ci‑dessous de commande d'une led RGB est constitué d'une led RGB dont :

• la cathode commune est directement reliée à la broche GND de la carte ;
• les trois anodes R (red) G (green) B (blue) sont respectivement reliées aux broches PWM 9 10 11 de la carte, chacune via une résistance de limitation de courant de 220 Ω.
Sachant qu'en synthèse additive W, chaque composante de couleur primaire est usuellement codée par un entier compris en 0 et 255, on peut très facilement afficher n'importe laquelle des 16 millions de nuances possibles. Il suffit de passer directement cette valeur comme celle de l'argument value dans la fonction analogWrite, appliquée à la broche correspondante.
On peut même procéder avec du code hexadécimal sans avoir à effectuer de conversion. Par exemple, la couleur HTML/CSS MediumOrchid  dont le code est #BA55D3 s'obtient avec les trois appels successifs de la fonction analogWrite (cf. les lignes n° 12 à 14) dans le programme ci‑dessous.

const uint8_t LED_RED_PIN   = 6;
const uint8_t LED_GREEN_PIN = 10;
const uint8_t LED_BLUE_PIN  = 11;

void setup()
{
  pinMode(LED_RED_PIN,   OUTPUT);
  pinMode(LED_GREEN_PIN, OUTPUT);
  pinMode(LED_BLUE_PIN,  OUTPUT);

  // color:   Medium Orchid #BA55D3
  analogWrite(LED_RED_PIN,   0xBA);
  analogWrite(LED_GREEN_PIN, 0x55);
  analogWrite(LED_BLUE_PIN,  0xD3);
}

void loop()
{
  delay(10); // for a quicker Tinkercad simulation
}