Pour chaque microcontrôleur, un compilateur C++ spécifique, au moins conforme à la norme C++11 a été développé. Ce sont ces compilateurs qui sont mis en œuvre par le logiciel Arduino IDE pour produire un code exécutable à partir du code source fourni par le programmeur.

La nouvelle gamme de cartes Arduino à processeur 32 bits

La carte Uno R4

Le modèle phare de cette nouvelle gamme est la carte Uno R4 qui se décline en deux variantes : la Minima et la WiFi.

Destinée à remplacer la Uno R3, la carte Uno R4 Minima A en adopte logiquement la même forme. Pour un prix un peu moins élevé (18 €), elle en améliore significativement les aspects suivants :
• Elle embarque un microcontrôleur Renesas RA4M1 à architecture ARM Cortext M4 32 bits cadencé à 48 MHz avec 256 ko de mémoire flash (pour le code exécutable), et 32 ko de RAM.
• En plus des fonctionnalités d'entrées‑sorties usuelles du modèle Uno R3 (cf. supra ), ce microcontrôleur dispose d'un CAN (convertisseur analogique numérique) dont la résolution peut être poussée à 14 bits, d'un CNA (convertisseur numérique analogique 12 bits et d'un bus CAN (controller area network).
• La liaison avec le poste de travail est assurée par un connecteur USB micro C.

Quant à la carte Uno R4 WiFi A, à peine plus chère (25 €), elle vient en remplacement de la Uno WiFi Rev2 (qu'on trouvait encore en 2023 pour environ 50 €). En plus des caractéristiques de la Minima, on peut essentiellement citer les améliorations suivantes :
• Pour assurer la connectivité Wi‑Fi et Bluetooth, elle embarque un module ESP32‑S3‑Mini‑1‑N8 (cf. supra ). De plus, ce module peut être programmé indépendamment du microcontrôleur principal grâce à un connecteur à broches Dupont mâles 3 × 2.
• Elle possède une matrice de 12 × 8 led rouges sur sa face, qui se pilote facilement par le biais d'une bibliothèque logicielle.
• Elle implémente une horloge temps‑réel qui peut être maintenue en veille même quand la carte est éteinte via une broche dédiée (VTRC).
• Elle dispose d'un connecteur Qwiic qui facilite grandement sa liaison par bus  I²C à tout un écosystème de capteurs (cf. ce lien commercial à titre d'exemple ).

Autres nouvelles cartes (Nano, Giga…)

Dans la même philosophie, la marque Arduino propose également les nouvelles cartes suivantes.

• Pour les applications embarquées, la Nano ESP32 A (18 €), qui vient en remplacement de la traditionnelle Nano.
Son microcontrôleur principal est un ESP32‑S3 avec les connectivités Wi‑Fi et Bluetooth (cf. supra ).
• Pour les applications exigeantes en performances (vitesse, mémoire), la Giga R1 WiFi A (69 €), qui vient en remplacement de la Due.
• Son microcontrôleur est un STM32H747XI à double cœur ARM Cortex M7 et M4, cadencés respectivement à 480 et 240 MHz.
• Elle embarque également un chipset Murata 1DX qui assure les connectivités Wi‑Fi et Bluetooth.

Plus en détails, un module ESP est essentiellement constitué, en plus de son microcontrôleur, d'un oscillateur à quartz, d'une unité de mémoire flash externe et d'une antenne Wi‑Fi – cf. le module ESP‑12F à microcontrôleur en photo ci‑contre avec et sans son blindage.

De plus, la plupart des modules à microcontrôleur ESP8266 embarquent une led intégrée.

Dans le commerce, on trouve aussi toutes sortes de cartes de développements (development kit) qui embarquent un module à microcontrôleur ESP8266 W ou ESP32. Les deux exemples décrits ci‑dessous sont typiques de ceux que l'on peut utiliser en prototypage d'objets connectés.

La carte de développement Joy‑It SBC‑NodeMCU (ESP8266)

À peine plus grande qu'une Arduino Nano, la carte SBC‑NodeMCU  de l'assembleur allemand Joy‑It présente des caractéristiques nettement supérieures, et pour un prix deux fois moindre :

• microcontrôleur ESP8266 à processeur Tensilica Xtensa LX106 32 bits embarqué dans un module ESP‑12E  ;
• fréquence d'horloge jusqu'à 160 MHz ;
• mémoire flash interne 96 ko (programme) ;
• mémoire SRAM 64 ko (données) ;
• mémoire flash externe 4 Mo ;
• module Wi‑Fi 2,4 GHz normes 802.11 b/g/n
• port d'entrées‑sorties polyvalent (GPIO) 16 broches en 3,3 V  :
• CAN ajustable sur 10 bits, 1 broche ;
• 16 broches PWM sur 10 bits ;
• 1 bouton‑poussoir (« flash ») et 2 led intégrés (tous câblés en logique négative) ;
• protocoles UART, SPI, HSPI, I²C, SDIO ;
• port USB micro B qui combine alimentation et convertisseur pour liaison série via un ASIC Silicon Labs CP2102  (à oscillateur interne 48 MHz) ;
• coût 10 €, poids 8 g, dimensions 49 × 26 mm.

Le plan de brochage de la carte (pinout) est disponible au lien suivant .

La carte de développement Joy‑It NodeMCU ESP32

Un peu plus grande que la SBC‑NodeMCU présentée supra , la carte NodeMCU ESP32  de la même marque Joy‑It a des caractéristiques encore supérieures, pour un prix à peine plus cher :

• microcontrôleur ESP32 à processeur Tensilica Xtensa LX6 32 bits double cœur embarqué dans un module ESP‑WROOM‑32 (wireless room) ;
• fréquence d'horloge jusqu'à 240 MHz ;
• mémoire flash 4 Mo (programme) ;
• mémoire SRAM 512 ko (données) ;
• module Wi‑Fi 2,4 GHz normes 802.11 b/g/n ;
• module Bluetooth classic et LE (low energy) ;
• port d'entrées‑sorties polyvalent (GPIO) 16 broches en 3,3 V  :
• CAN ajustable sur 12 bits, 15 broche ;
• CNA sur 8 bits, 2 broche ;
• 16 broches PWM sur 16 bits ;
• 1 bouton‑poussoir (« boot ») et 2 led intégrés (tous câblés en logique négative) ;
• protocoles UART (2), SPI, VSPI, I²C, SDIO ;
• port USB micro B qui combine alimentation et convertisseur pour liaison série via un ASIC Silicon Labs CP2102 (à oscillateur interne 48 MHz) ;
• coût 12,5 €, poids 8 g, dimensions 48 × 38 mm.

Le plan de brochage de la carte (pinout) est disponible au lien suivant .

Le microcontrôleur Atmel ATtiny85

Par absence de port USB, un montage ad hoc ou une carte spécifique de programmation avec un convertisseur USB‑série (cf. la photo ci‑dessous) est nécessaire pour téléverser le programme via le logiciel Arduino IDE.

Les caractéristiques de ce microcontrôleur sont les suivantes (plusieurs valeurs selon le modèle)  :

• architecture Harvard 8 bits ;
• fréquence d'horloge 10 ou 20 MHz ;
• mémoire flash 2 à 8 ko (programme) ;
• mémoire SRAM 128 à 512 o (données) ;
• mémoire EEPROM 128 à 512 o ;
• port d'entrées‑sorties polyvalent (GPIO) 6 broches :
• CAN ajustable 5 V sur 8 ou 10 bits, 4 broches ;
• port numérique 5 V, 6 broches (3 en pwm sur 8 bits) ;
• protocoles UART, SPI, I²C.
• coût 2 €, poids 1 g, dimensions 10 × 7 mm.

Le plan de brochage (pinout) du microcontrôleur est disponible au lien suivant .

Pour accéder à la documentation technique des cartes tierces (cf. supra ), il faut consulter d'autres sites. En particulier, pour les pages de références logicielles des cartes à SoC ESP8266, on pourra consulter ce lien .

Avec l'IDE Arduino, il n'est pas possible de choisir la version de la norme (cf. chap. C1‑II ) du langage C++ qui est appliquée lors de la compilation. Néanmoins, on peut savoir quelle est cette version en codant le programme ci‑dessous :

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

void loop() {}

En compilant et téléversant le code dans une carte Arduino Uno R3 , on obtient dans la fenêtre du moniteur série l'affichage 201103. La chaîne de compilation pilotée par avr-g++ est donc en principe conforme à la norme C++11.

Quant au bouton juste à gauche, il permet d'activer dans une fenêtre graphique supplémentaire le traceur série (serial plotter). On y trouve en abscisses une échelle de temps et en ordonnée l'échelle des valeurs numériques en sortie sur le port série de la carte. Les variations de ces valeurs sont tracées en temps‑réel.

Emploi d'un éditeur de code externe

L'emploi d'un éditeur de code externe plus performant, comme Sublime Text ou VS Code, devient d'autant plus pertinent que le programme développé est complexe et réparti sur un grand nombre de fichiers. On peut alors bénéficier d'une coloration syntaxique avancée et des outils de navigation et de re‑factorisation de cet éditeur tout en gardant l'usage de la chaîne de compilation et de téléversement fourni par Arduino IDE, qui n'est pas facile d'installer sur un éditeur externe.

Le gestionnaire de bibliothèques

Dans les version 2.x d'Arduino IDE, par rapport aux versions précédentes, l'ergonomie du gestionnaire de bibliothèques est améliorée. Il est accessible par un raccourci dans la colonne de boutons à gauche de la fenêtre principale et s'ouvre dans un panneau latéral (cf. la capture d'écran ci‑contre).

Pour installer un module de bibliothèque référencé, le plus simple est de taper son nom dans la barre de recherche. Si le texte tapé contient un mot coïncidant avec celui d'un module existant dans la base de donnée des modules référencés Arduino, il est alors proposé à l'installation. Il suffit de cliquer sur le bouton  INSTALL.

Attention ! Pour un même thème ou un composant donné, il existe très souvent de nombreux modules de bibliothèque. Pour ne pas les confondre et savoir lequel est requis par un programme donné, on peut s'aider du nom des auteurs comme élément d'identification.

Un panorama des modules de bibliothèques les plus usuels est proposé au chapitre C4‑VII 

Le gestionnaire de cartes

À l'instar du gestionnaire de bibliothèques, dans les version 2.x d'Arduino IDE, par rapport aux versions précédentes, l'ergonomie du gestionnaire de cartes est également améliorée, avec un raccourci placé dans la colonne de boutons à gauche de la fenêtre principale et s'ouvre dans un panneau latéral (cf. la capture d'écran ci‑contre).

Pour installer la chaîne de compilation et les fichiers de bibliothèques du noyau d'une type particulier de cartes (par exemple, une Due – cf. supra), le plus simple est de taper le nom de ce type dans la barre de recherche. Si le texte tapé contient un mot reconnu par le moteur de recherche associé à la barre, un ou plusieurs types de cartes sont proposés à l'installation. Il suffit de choisir celui voulu en cliquant sur le bouton  INSTALL.

En plus des cartes Arduino usuelles (ou de leurs clones), il est possible avec Arduino IDE d'installer des cartes tierces (cf. supra ). Toutefois, elles ne sont pas répertoriées par défaut par le gestionnaire de cartes.

Pour y remédier, il suffit d'ajouter une URL spécifique à chaque type de cartes tierces dans la fenêtre de préférences (menu Fichier), dans la barre prévue à cet effet (cf. la capture d'écran ci‑dessous). Elle pointe vers un fichier au format JSON qui lui‑même contient, pour chaque modèle de cartes, une URL pointant vers un fichier d'archive contenant la chaîne de compilation adaptée à ce modèle.

Une fois que le type de cartes tierces est référencé par le gestionnaire de cartes, l'installation peut être effectuée comme pour n'importe quel autre type de cartes Arduino. Attention, une telle opération prend une durée non négligeable (plusieurs minutes), puisqu'il faut télécharger et installer sur le poste de travail toute la chaîne de compilation nécessaire pour les programmer.

Le logiciel Arduino en ligne de commande

En alternative à Arduino IDE, on peut exploiter les cartes Arduino et compatibles via une application en ligne de commande nommée Arduino CLI A – pour command line interface.

Éventuellement exploitée par une minorité d'utilisateurs experts, cette solution a surtout été développée pour permettre d'interfacer les fonctionnalités Arduino dans des IDE généralistes comme par exemple VS Code (cf. infra ).

On trouve tous les détails nécessaires à l'installation et la prise en main d'Arduino CLI à partir du fichier README.md publié sur la page d'accueil Github suivante G.

Prise en charge d'Arduino dans VS Code

Grâce à diverses extensions, le logiciel VS Code (cf. chap. C1‑II ) peut prendre en charge le framework Arduino, non seulement pour l'édition de code source – avec les fonctionnalités IntelliSense – mais aussi pour toutes les fonctionnalités d'Arduino IDE : téléversement du programme, moniteur série, gestionnaire de cartes, etc.

L'extension Arduino Community Edition

L'extension Arduino Community Edition émule toutes les fonctionnalités d'Arduino IDE sans nécessiter que cette application soit installée sur le poste de travail. Pour cela :

• elle intègre une version spécifique d'Arduino CLI (cf. supra ) dite bundle – c'est‑à‑dire groupée avec l'extension.

elle exploite une autre extension nommée Serial Monitor (développée par Microsoft) pour mettre en œuvre les communications série entre une carte Arduino et le poste de travail, qui sont indispensables pour le téléversement de programmes.

L'installation ne pose aucune difficulté, il suffit de procéder comme pour toute extension via le Marketplace en cliquant sur le bouton bleu Install (cf. chap. C1‑II ). L'extension Serial Monitor est automatiquement installée dans la foulée.

Une fois l'extension installée, avant toute prise en main, il est recommandé d'activer la fonctionnalité Arduino CLI intégrée dans l'extension. Pour cela, on peut par exemple faire un clic‑droit sur l'extension listée dans le panneau latéral et, dans le menu contextuel ainsi ouvert, choisir Settings. Il suffit alors de cocher la case correspondant à l'option idoine, comme sur la capture d'écran ci‑dessous.

Ce choix est alors enregistré dans le fichier de préférences settings.json de l'utilisateur par la ligne de code :
"arduino.useArduinoCli": true
sachant qu'on peut aussi directement coder cette ligne pour effectuer le même réglage.

Quant à la prise en main, elle est assez simple, à condition de bien respecter l'ordre des opérations comme indiqué ci‑après.

1. Pour commencer, il faut créer un répertoire de projet ; à titre d'exemple de démonstration, partons sur un classique HelloWorld. On peut alors ouvrir ce répertoire via la commande File/Open Folder….

2. Dans ce répertoire, via la commande File/New File… on crée un nouveau fichier qui, conformément aux usages dans le framework Arduino (cf. chap. C2‑I ), doit impérativement :
• être homonyme avec le répertoire de projet (same basename) ;
• avoir l'extension .ino.
donc dans notre exemple HelloWorld.ino. Typiquement, on peut y coder le programme suivant :

void setup()
{	
  Serial.begin(115200);
  Serial.println("Hello, World!");
}

void loop() {}

Remarque : par son extension .ino, ce fichier est automatiquement identifié par VS Code comme un fichier source Arduino. Lors de la première prise en main du logiciel, Une fenêtre pop‑up en bas de la fenêtre principale propose alors d'installer un pack d'extensions C/C++, mais ce n'est pas indispensable.
3. Via la palette de commande (activée par la touche F1), il est alors impératif de lancer la commande Arduino: Initialize. Elle crée automatiquement dans le répertoire de projet un sous‑répertoire .vscode et, dans ce dernier, un fichier nommé arduino.json où le fichier principal du programme (le sketch) est identifié. Dans notre exemple, on a :
   "sketch": "HelloWorld.ino"
4. Dans la barre de notifications en bas de la fenêtre principale, on remarque maintenant que plusieurs éléments de texte sont apparus, notamment une zone interactive :
   Select Board Type
   En cliquant dessus, on active un menu déroulant où l'on peut sélectionner le type de carte Arduino sur lequel on veut exécuter le programme. Sans même raccorder de carte au poste de travail, on peut faire ce choix, par exemple sélectionner le type Arduino Uno.
Cette action crée automatiquement dans le sous‑répertoire .vscode un fichier nommé c_cpp_properties.json qui configure la fonctionnalité IntelliSense, que l'on peut alors tester en survolant avec le pointeur de la souris les différents identificateurs du programme (setup, loop, Serial…) : des informations sur ces éléments doivent automatiquement s'afficher.
De plus, cette action ajoute automatiquement deux lignes dans le fichier arduino.json, précisant les valeurs respectives des paramètres "configuration" et "board".

5. On peut dès lors vérifier que le code est compilable avec la commande Arduino: Verify accessible via la palette de commande ou le bouton de raccourci spécifique aux fichiers .ino en haut à droite de la fenêtre d'édition (cf. la figure ci‑contre).
Ce faisant, le compte‑rendu de compilation s'affiche dans l'onglet OUTPUT sous la fenêtre d'édition.
6. Raccorder au poste de travail une carte du type choisi et, toujours dans la barre de notifications, cliquer sur la zone interactive :
   Select Serial Port
   Cette action ouvre un menu déroulant dans lequel on doit choisir le port USB du poste de travail sur lequel la carte est raccordée. Elle ajoute automatiquement dans le fichier arduino.json une ligne précisant la valeur du paramètres "port".

7. On peut dès lors téléverser le programme exécutable dans la carte avec la commande Arduino: Upload accessible via la palette de commande ou le bouton de raccourci en haut à droite de la fenêtre d'édition (cf. la figure ci‑contre).
Ce faisant, le compte‑rendu de téléversement s'affiche dans l'onglet OUTPUT sous la fenêtre d'édition.
8. Enfin, on peut observer l'exécution du programme dans l'onglet SERIAL MONITOR, en cliquant sur le bouton Start Monitoring : le message « Hello, World! » doit s'y afficher.

Par ailleurs, comme avec le logiciel Arduino IDE, on dispose de la possibilité d'ajout de nouvelles cartes et de nouvelles bibliothèques. Il suffit pour cela de taper la touche F1 pour accéder à la palette de commande, de saisir « Arduino » de sélectionner respectivement :

• Arduino: Board Manager
• Arduino: Library Manager

Dans les deux cas, on accède à une interface similaire à celle le logiciel Arduino IDE avec une barre de recherche un menu déroulant (cf. supra ).

Enfin, pour accéder à des cartes tierces, il faut éditer le fichier de préférences de l'utilisateur settings.json et ajouter une propriété de la forme :

  "arduino.additionalUrls": [
    "URL 1",
    "URL 2", // ...
  ],

Remarque. Isl est également possible de simuler le programme en mode pas‑à‑pas – ce qu'on appelle le débogueur – en imposant des points d'arrêt dans le code. Il suffit pour cela, avant de commencer la simulation, de cliquer sur n'importe quel numéro de ligne (et pour autant de lignes que l'on veut), qui porte alors une étiquette bleue. Alors :

• le programme s'arrête automatiquement au moment où arrive l'exécution de cette ligne ;
• on peut afficher les valeurs des variables à cet instant en passant le pointeur de la souris sur leur identificateur.

Pour avancer dans l'exécution du programme, on a alors deux possibilités :

• cliquer sur le bouton  pour aller au prochain point d'arrêt ;
• cliquer sur le bouton  pour aller à l'instruction suivante.

L'alternative Wokwi

Il existe une alternative gratuite à Tinkercad : le simulateur en ligne Wokwi développé par la société estonienne Codemagic . Cet outil a commencé à être développé en 2019 mais sa notoriété n'a vraiment touché le grand public que depuis 2024.

Contrairement à Tinkercad, il n'est pas obligatoire de créer un compte pour pouvoir utiliser le simulateur, qui est directement accessible au lien suivant Wokwi. Pour accéder à l'interface de développement, il suffit simplement de choisir le type de composant programmable (carte Arduino ou autre – le choix est appréciable).

Avec une souscription payante, il est même possible d'opérer en liaison avec un éditeur de code associé sur le poste de travail de l'utilisateur (VS Code ou JetBrain).

Comme Tinkercad, l'interface de développement se présente sous la forme d'une page web avec :

• un éditeur de code, avec ici une bonne coloration syntaxique ;
• un espace de travail pour construire le montage électronique autour du composant programmable, avec des mécanismes similaires :
• cliquer‑déposer pour insérer les composants depuis un menu déroulant (bouton ) ;
• cliquer‑tirer pour relier les composants avec des conducteurs dont on peut ensuite changer la couleur.

Le montage est temporairement mémorisé au format JSON dans l'onglet diagram.json que l'on peut consulter (ce n'est pas le cas avec Tinkercad).

Une fois que le montage et le code sont terminés, la sauvegarde peut se faire de deux manières :

• par copier/coller du contenu des onglets de code et du montage dans des fichiers sur le poste de travail (c'est la seule solution possible en usage libre sans compte utilisateur) ;
• par sauvegarde sur l'espace de stockage associé au compte utilisateur, en choisissant l'option « public project » (la sauvegarde de projets privés est possible mais pas gratuite).

Quant à la simulation, elle s'effectue directement en cliquant sur le bouton . Attention : la compilation sur le serveur peut prendre du temps.

Comparaison avec Tinkercad