Le choix du microcontrôleur est une décision critique qui façonne tous les aspects de votre projet robotique. Agissant comme système nerveux central du robot, le microcontrôleur traite les données du capteur, exécute des algorithmes de contrôle et commande les actionneurs. Une sélection bien informée permet d'économiser du temps, de réduire les coûts et d'éviter les goulets d'étranglement.

Comprendre les bases du microcontrôleur

Un microcontrôleur (MCU) est un circuit intégré compact conçu pour régir une opération spécifique dans un système intégré. Contrairement à un microprocesseur général, un MCU comprend des noyaux de processeur, des périphériques d'entrée/sortie programmables et des périphériques d'entrée/sortie sur une seule puce. Cette intégration le rend idéal pour la robotique, où l'espace, la puissance et les coûts sont limités.

Architecture et traitement des cœurs

La plupart des microcontrôleurs modernes utilisent soit des architectures ARM Cortex-M, AVR, ESP ou RISC‐V. ARM Cortex-M domine le segment de haute performance et de moyenne gamme, offrant un mélange équilibré de vitesse, d'efficacité énergétique et de soutien écosystémique étendu. L'architecture AVR (qui se trouve dans les premières cartes Arduino) reste populaire pour les tâches simples et de faible puissance. ESP32 et les puces associées combinent un processeur à double cœur Tensilica Xtensa avec Wi-Fi intégré et Bluetooth. RISC‐V est une architecture de standard ouvert émergente qui gagne en traction pour des conceptions sensibles aux coûts.

Les MCU 8 bits comme l'ATmega328 sont adaptés pour la lecture de base des capteurs et le contrôle moteur. Les MCU 32 bits comme la STM32 ou l'ESP32 fournissent la salle de tête nécessaire à la fusion complexe des capteurs, au prétraitement de la vision informatique ou aux boucles de contrôle en temps réel.

Types de mémoire

Les microcontrôleurs contiennent deux types principaux de mémoire : la mémoire flash pour stocker le programme et la RAM statique (SRAM) pour les données d'exécution, les variables et les piles. Les tailles Flash vont de 2 KB sur les minuscules PIC à 2 MB+ sur les pièces haut de gamme STM32. SRAM est plus limité, généralement 256 octets à 512 KB. Pour la robotique, allouer suffisamment de flash pour votre firmware plus bibliothèques, et assez SRAM pour tenir les tampons de capteur, les variables d'état et les files d'attente de communication.

Périphériques et interfaces

Les périphériques intégrés sur puce déterminent quels composants externes vous pouvez connecter sans logique de colle supplémentaire. Les périphériques standard comprennent:

  • Entrée/sortie générale (GPIO) – pour capteurs numériques et actionneurs simples.
  • Convertisseurs analogiques à numériques (ADC) – essentiel pour les capteurs analogiques (p. ex. potentiomètres, capteurs de distance).
  • Modulation de la largeur des impulsions (MFP) – contrôle les servomoteurs, la vitesse du moteur DC et la luminosité LED.
  • Communication en série: UART, I2C, SPI – pour l'interface avec les IMU, les moteurs, les écrans et autres périphériques.
  • Timeurs et compteurs – générer des retards précis, mesurer la largeur des impulsions et produire des interruptions périodiques pour les boucles de commande.
  • Réseau de zone de contrôleur (CAN) – utilisé dans la robotique industrielle et automobile pour une communication multinoeud robuste.
  • USB – permet une communication directe avec un PC pour la programmation et le débogage.
  • Interruptions externes – réagir à des événements comme les tiques d'encodeur ou les interrupteurs de limite sans sondage.

Choisissez un MCU qui fournit suffisamment de chaque type périphérique pour vos besoins actuels et futurs. Par exemple, un robot avec quatre moteurs à courant continu, deux servomoteurs, une douzaine de capteurs et un module Bluetooth peut avoir besoin d'au moins huit canaux PWM, six entrées analogiques et deux UART.

Facteurs clés à considérer

Puissance de traitement

La puissance de traitement est déterminée par la vitesse de l'horloge, la largeur du bit et la présence d'un module à point flottant (FPU). Les robots simples de suivi de ligne peuvent fonctionner sur des MCU 8 bits à 16 MHz. Un robot auto-équilibrage qui nécessite des boucles PID rapides bénéficie d'un MCU 32 bits à 80-240 MHz avec un FPU pour éviter les frais de calcul fixes. Si vous prévoyez de mettre en œuvre une vision informatique (même une simple détection d'objets), considérez un MCU plus haut de gamme ou un module système sur-comme le Raspberry Pi. Utilisez MIPS (en millions d'instructions par seconde) comme comparateur brut : un AVR 16 MHz délivre environ 16 MIPS, alors qu'un Cortex‐M7 240 MHz peut dépasser 1000 MIPS.

Pins d'entrée/sortie

Comptez le nombre total d'épingles numériques et analogiques dont vous avez besoin, y compris celles utilisées pour les protocoles de communication. Beaucoup de MCU ont des fonctions alternatives sur les épingles (p. ex., une épingle peut être soit GPIO, UART TX, ou PWM), donc assurez-vous que vos assignations de broches ne sont pas en conflit. Pour les projets avec de nombreux capteurs, considérez un MCU avec une architecture multiplexée ou un qui prend en charge les expansionurs externes.

Consommation d'énergie

Les robots alimentés par batterie exigent une faible consommation d'énergie. Cherchez des MCU avec plusieurs modes de sommeil, tels que le ralenti, la réduction de puissance et le sommeil profond. L'ESP32 peut dessiner 60 mA en mode actif mais seulement 5 μA en sommeil profond. Pour les projets qui doivent fonctionner pendant des semaines, choisissez un MCU avec un courant actif faible (inférieur à 10 mA à des vitesses d'horloge modérées) et un réveil efficace des interruptions externes.

Connectivité

Si vous avez besoin de Wi-Fi, Bluetooth BLE ou les deux, le ESP32 est un choix naturel. Pour LoRa ou Zigbee, regardez les MCU avec des modules radio appropriés. Si votre robot communique sur cellulaire local (NB‐IoT), choisissez un MCU avec un modem cellulaire compatible. Pour les opérations liées ou l'utilisation avec un Raspberry Pi à bord, assurez-vous que le MCU supporte USB ou SPI haute vitesse.

Écosystèmes de développement

Un écosystème fort accélère le prototypage et le débogage.

  • IDE et chaîne d'outils: Arduino IDE, PlatformIO, STM32CubeIDE ou environnements basés sur l'Eclipse.
  • Bibliothèques Les bibliothèques robustes pour capteurs, moteurs et protocoles de communication réduisent le temps de développement.
  • Soutien communautaire: Les forums actifs, les exemples GitHub et les réponses Stack Overflow aident quand vous êtes coincé.
  • Documentation: Des fiches techniques complètes, des manuels de référence et des notes d'application sont essentiels pour une utilisation avancée.
  • Déboguement : Les débogueurs sur puce (SWD, JTAG) facilitent le passage des questions de code et de trace. Les cartes Arduino ne s'appuient souvent que sur le débogage en série, ce qui est acceptable pour les projets simples.

Capacités en temps réel

Un système d'exploitation en temps réel (RTOS) comme FreeRTOS peut aider à planifier les tâches, mais le MCU sous-jacent doit avoir suffisamment de niveaux d'interruption prioritaires, de latences d'interruption faibles et de minuteurs matériels. Les microcontrôleurs ARM Cortex‐M3/4/7 excellent ici, offrant des contrôleurs d'interruptions imbriqués avec 16 niveaux de priorité et une manipulation d'interruption à cycle unique.

Coût et disponibilité

Les contraintes budgétaires entraînent souvent des décisions. Un MCU de 8 bits peut coûter moins de 1 $ en volume, tandis qu'un STM32 haut de gamme avec 2 Mo flash et un noyau DSP peut dépasser 15 $. Cependant, le coût des composants supplémentaires est facteur : si un MCU moins cher nécessite un Wi-Fi externe ou des expansions GPIO supplémentaires, le total peut dépasser celui d'une puce plus intégrée.

Microcontrôleurs populaires comparés

Arduino (fondé sur l'AVR)

L'Arduino Uno (ATmega328P) reste le point d'entrée le plus accessible pour les débutants robotiques. Il fournit 14 broches numériques (6 PWM), 6 entrées analogiques, 32 KB flash et 2 KB SRAM. Sa simplicité et sa communauté énorme le rendent idéal pour les premiers projets, comme un suiveur de ligne à deux roues ou un bras robotique avec trois servos. Les limitations deviennent apparentes avec des tâches complexes : l'architecture 8-bit se heurte à des maths flottants, et la mémoire est trop serrée pour de nombreuses bibliothèques simultanément.

Raspberry Pi (Broadcom SoC)

Le Raspberry Pi est un ordinateur mono-board qui gère un système d'exploitation Linux complet. Son SOC Broadcom contient un puissant processeur ARM Cortex‐A72 (Pi 4) ou Cortex‐A76 (Pi 5), jusqu'à 8 Go de RAM, et des capacités multimédias. Il excelle dans la robotique nécessitant un calcul lourd : traitement de vision, planification du chemin, serveurs web ou localisation et cartographie simultanées (SLAM). Cependant, il n'est pas un véritable microcontrôleur – il consomme 2-15 W de puissance, a besoin d'un apport stable de 5 V, et manque de comportement déterministe en temps réel (bien que vous puissiez utiliser un microcontrôleur embarqué comme le RP2040 sur Pi Pico pour des tâches de bas niveau).

ESP32

L'ESP32 est un MCU 32 bits double cœur avec Wi-Fi intégré et Bluetooth BLE. Il fonctionne à 80-240 MHz, offre 520 KB SRAM (expandable avec PSRAM), et flash de 4-16 MB. Sa popularité en IoT en a également fait un favori robotique. Les cas d'utilisation typiques incluent des rovers qui diffusent la vidéo, des bras robotisés contrôlés sur Wi-Fi ou une coordination multirobot via MQTT. Le SDK basé sur FreeRTOS fournit un multitâche préemptif, et le noyau Arduino est largement pris en charge.

STM32

La famille STMicroelectronics amples ensembles périphériques sont disponibles : plusieurs minuteurs haute résolution (jusqu'à 32 bits), CAN FD, USB OTG et des minuteurs de commande motorisés dédiés. Les séries STM32F3 et G4 comprennent des instructions FPU et DSP, ce qui les rend idéales pour la fusion de capteurs et les boucles de commande rapides. L'écosystème comprend des bibliothèques STM32CubeIDE, HAL et LL, et de nombreux ports RTOS tiers. Les pièces STM32 sont plus complexes que celles d'Arduino, mais pour la robotique de qualité de production (par exemple, robots mobiles autonomes, drones, bras industriels), elles sont la norme or.

Adolescents

La gamme PJRC=S Teensy (Teensy 4.0/4.1) offre une impressionnante gamme NXP i.MX RT1062 Cortex‐M7 fonctionnant à 600 MHz, avec 1 MB RAM, 2 MB flash (expandable via QSPI) et des périphériques riches. Il est compatible Arduino via Teensyduino, qui ajoute des bibliothèques avancées pour audio, USB et CAN. La performance brute rivalise avec Raspberry Pi bas de gamme dans le calcul numérique, mais elle reste déterministe.

La décision finale

Commencez par définir les exigences fonctionnelles de votre robot : listez tous les capteurs, actionneurs, liens de communication et tâches informatiques. Groupez-les en --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Pour un simple suiveur de ligne avec deux moteurs et trois capteurs, tout MCU 8 bits (Arduino Nano) fonctionne. Pour un bras robotique avec six servomoteurs, un préhenseur et un capteur de force, un MCU 32 bits avec plusieurs canaux de minuterie (STM32F3 ou Teensy) simplifie le code. Pour un robot à essaim qui communique sur Wi‐Fi, ESP32 est le choix évident. Pour un robot de recherche qui gère des algorithmes de navigation et publie des sujets ROS, considérez un Raspberry Pi comme l'ordinateur principal avec un ESP32 ou STM32 comme coprocesseur pour le contrôle de bas niveau.

Prototyper sur une plate-forme populaire (Arduino ou ESP32) même si vous prévoyez de passer à une carte plus personnalisée plus tard. L'écosystème vous permet de tester votre concept rapidement. Une fois l'algorithme et le matériel validé, vous pouvez redessiner le PCB autour d'un MCU plus rentable si nécessaire.

Enfin, vérifiez les contraintes en temps réel. Si votre robot doit fermer une boucle de commande à 1 kHz, assurez-vous que le MCU peut lire tous les capteurs, calculer la sortie du contrôleur et mettre à jour les actionneurs dans les 1 ms, laissant la tête de la machine pour d'autres tâches. Effectuez une analyse du temps d'exécution dans les pires cas (WCET) en utilisant le code exemple et les mesures de l'oscilloscope avant de commettre.

Conclusion

En évaluant systématiquement les besoins spécifiques de votre robot par rapport aux capacités des plateformes comme Arduino, Raspberry Pi, ESP32, STM32 et Teensy, vous pouvez faire un choix éclairé qui met le projet en place pour le succès. Commencez par une liste claire des exigences, un prototype sur une carte bien supportée, et seulement après considérer le matériel personnalisé. La bonne base permettra d'économiser d'innombrables heures de débogage et vous permettra de vous concentrer sur la partie vraiment créative de la robotique – le comportement et l'intelligence de votre création.