Arduino Uno

Présentation

L’Arduino Uno est une petite carte de développement construite autour de l’ATmega328P de Microchip, un microcontrôleur 8 bits. Elle expose les broches de la puce sur des connecteurs étiquetés, ajoute un port USB pour la programmation et l’alimentation, et gère les parties délicates — régulateur de tension, quartz d’horloge, circuit de reset — pour vous laisser vous concentrer sur le code et le câblage. Pour une énorme part des apprenants en robotique, l’Uno est la façon dont ils font tourner un moteur ou allumer un capteur pour la première fois.

Son attrait durable n’est pas la puissance brute — aux standards modernes, il est lent et avare en mémoire. C’est le pardon. Les broches 5 V tolèrent les erreurs de câblage des débutants, la communauté a répondu à presque toutes les questions possibles, et presque chaque capteur et pilote loisir est livré avec un exemple qui suppose un Uno.

Fonctionnement

Vous écrivez un croquis — un programme C++ à deux fonctions. setup() s’exécute une fois à la mise sous tension ; loop() tourne ensuite pour toujours. À l’intérieur, vous lisez les entrées et pilotez les sorties via les broches :

• Broches numériques lisent ou écrivent un signal HAUT/BAS (5 V / 0 V) — un appui de bouton, une LED, l’entrée de direction d’un pilote moteur.
• Broches PWM (marquées ~) simulent une tension analogique en commutant très vite. C’est ainsi qu’on règle la vitesse moteur ou la luminosité d’une LED.
• Entrées analogiques mesurent une tension de 0–5 V et la rapportent comme un nombre de 0–1023. C’est ainsi qu’on lit un potentiomètre ou un capteur de ligne analogique.

L’Uno n’a pas de système d’exploitation. Votre code est la seule chose qui tourne, ce qui rend la temporisation prévisible — précieux quand on boucle une commande autour d’un vrai robot.

Quand l’utiliser

Prenez un Uno quand vous apprenez, quand vous voulez la plus grande pile possible de tutoriels et bibliothèques compatibles, ou quand le travail de votre robot est simple et temps réel : lire quelques capteurs, exécuter une boucle de commande, entraîner deux moteurs. Un suiveur de ligne, un éviteur d’obstacles ou un petit rover différentiel sont carrément dans sa zone de confort.

Regardez ailleurs quand il faut du Wi-Fi ou Bluetooth (un ESP32 est l’évolution habituelle), des maths lourdes ou de la vision par caméra (un Raspberry Pi), ou beaucoup de mémoire. Les 2 Ko de SRAM de l’Uno se remplissent plus vite que les débutants ne l’imaginent — longues chaînes et grands tableaux sont les coupables habituels.

Pièges courants

• C’est une carte 5 V. Beaucoup de capteurs modernes sont en 3,3 V et peuvent être endommagés par la logique 5 V. Vérifiez la fiche technique avant de câbler.
• N’alimentez pas les moteurs depuis la carte. Le régulateur de l’Uno ne peut pas fournir le courant moteur ; utilisez une batterie séparée et un pilote moteur. Alimenter les moteurs via l’Uno est la façon la plus courante de faire décrocher ou redémarrer sa carte pour un débutant.
• delay() bloque tout. Pendant un delay(), la carte ne peut ni lire les capteurs ni réagir. Pour tout comportement réactif, mesurez le temps avec millis().
• Surveillez votre mémoire. Si la carte se comporte bizarrement sans raison claire, vous manquez peut-être de SRAM.

Brochage : ce que chaque broche peut vraiment faire

Quatorze broches numériques et six analogiques, mais elles ne sont pas interchangeables. Six d’entre elles ont un second rôle qui compte.

Deux de ces lignes façonnent la plupart des conceptions robotiques. D2 et D3 sont les seules vraies broches d’interruption, ce qui signifie qu’un robot à deux encodeurs de roues les utilise toutes deux et n’en a plus. Et A4/A5 sont le bus I²C, donc un MPU-6050 plus un réseau de capteurs analogiques sur un Uno se disputent aussitôt les broches.

Cette pression sur les broches est la raison la plus fréquente de dépasser un Uno — pas la vitesse, pas la mémoire. Quatorze numériques et six analogiques disparaissent vite une fois qu’on a un pilote moteur (6 broches), une paire d’encodeurs (4 broches, dont 2 interruptions), et un réseau de capteurs (6 analogiques).

L’alimenter, et les trois façons de s’y tromper

Le régulateur est linéaire, ce qui signifie qu’il brûle la différence entre l’entrée et 5 V en chaleur. À 12 V en entrée et 200 mA tirés, cela fait (12 − 5) × 0,2 = 1,4 W dans un petit boîtier, et il chauffe vraiment. Alimentez en 9 V plutôt qu’en 12 V si vous avez le choix.

Trois erreurs précises à nommer :

Alimenter les moteurs depuis la broche 5 V. Le régulateur ne peut pas fournir le courant moteur, donc le rail chute, la carte redémarre, et le symptôme ressemble à un plantage logiciel. Les moteurs ont leur propre alimentation et ne partagent que la masse.

Alimenter la broche 5 V depuis une source non régulée. Cette broche est directement sur le rail, donc tout ce qui dépasse environ 5,5 V va droit dans l’ATmega328P.

Alimenter à la fois par USB et la prise. La carte gère cela (un comparateur sélectionne la source la plus haute), mais une batterie sur la prise ne chargera pas et peut réinjecter via une conception limite sur un clone.

Ce que les broches peuvent vraiment fournir

La broche 3,3 V piège régulièrement. Ce n’est pas un rail d’usage général ; c’est une commodité à 50 mA. Un module ESP-01 en émission décrochera dessus aussitôt.

Le problème des 2 Ko de mémoire

L’Uno a 32 Ko de flash pour votre programme et 2 Ko de SRAM pour ses variables en cours d’exécution. La flash est rarement la contrainte. La SRAM l’est, constamment.

Chaque littéral de chaîne dans un Serial.print est copié en SRAM au démarrage :

Serial.println("Calibration complete, entering drive mode");   // 43 bytes of SRAM, forever

Vingt tels messages font 800 octets — 40 % du total. La solution est F(), qui laisse la chaîne en flash et la lit au besoin :

Serial.println(F("Calibration complete, entering drive mode"));  // 0 bytes of SRAM

Les tableaux sont l’autre consommateur. Un float fait 4 octets, donc un tampon d’enregistrement de 200 échantillons fait 800 octets sans aucun avertissement — le compilateur rapporte joyeusement l’usage flash et ne dit rien d’utile sur la SRAM d’exécution.

Le symptôme d’épuisement n’est pas une erreur propre. La pile grandit vers le bas, le tas vers le haut, et quand ils se rencontrent, les variables se corrompent silencieusement. La carte se comporte bizarrement : lectures insensées, boucle qui saute, reset sans cause. Si un Uno commence à se comporter irrationnellement après l’ajout d’une fonction, suspectez la SRAM avant tout.

// Drop this in and watch it while you develop.
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

Sous environ 200 octets libres, attendez-vous à des ennuis.

Dépannage

Uno ou autre chose ?

La Nano mérite une mention pour les robots : c’est le même ATmega328P avec le même code, et elle expose A6 et A7 en entrées analogiques supplémentaires. Pour un réseau de réflectance à 8 canaux, c’est la différence entre tenir ou non, et c’est exactement pourquoi les suiveurs de ligne spécifient si souvent une Nano.

Le résumé honnête : la valeur de l’Uno est que tout y fonctionne du premier coup. Chaque bibliothèque, chaque tutoriel, chaque schéma suppose l’Uno. Cela vaut plus pendant l’apprentissage que toute spécification, et quand vous la dépassez, ce que vous dépassez sera presque toujours le nombre de broches.