Arduino CLI transforme la façon de travailler avec les cartes Arduino. En ligne de commande, l’outil ouvre l’accès à des workflows automatisés, intégrés aux systèmes de build, aux pipelines CI/CD et aux éditeurs de code modernes.
Entre installation, configuration fine et scénarios d’usage avancés, de nombreux détails changent la productivité au quotidien. Les possibilités vont bien au‑delà d’un simple remplacement de l’IDE graphique…
| Élément clé | Synthèse |
| Rôle de l’outil | Utilitaire en ligne de commande pour compiler, gérer et déployer des projets Arduino ⚡ |
| Actions principales | Installation de cartes & bibliothèques, compilation de sketchs, upload sur microcontrôleurs. |
| Avantages | Automatisation, intégration CI/CD, légèreté et rapidité par rapport à l’IDE. |
| Public cible | Développeurs souhaitant industrialiser ou automatiser leurs workflows. |
Arduino CLI : principe, usages et différences avec l’IDE classique
Arduino CLI est un outil en ligne de commande qui pilote l’écosystème Arduino sans interface graphique. Il gère l’installation des cœurs de cartes, la compilation des sketchs, le téléversement, la détection des ports série et l’intégration avec d’autres outils comme VS Code ou des serveurs d’intégration continue.
L’outil répond à une demande croissante d’automatisation des workflows embarqués. De nombreux concepteurs souhaitent versionner complètement leurs projets, industrialiser les builds, intégrer les tests et déployer du firmware sur des parcs de cartes. L’IDE historique reste utile pour débuter, mais il limite ces scénarios avancés.
Les forums Arduino rassemblent plus de 3 000 000 d’utilisateurs, et environ 70 % des concepteurs et ingénieurs déclarent utiliser Arduino dans leur processus de prototypage. La CLI s’inscrit dans cette dynamique en offrant une approche plus proche des outils de développement traditionnels (Make, CMake, scripts Bash, pipelines GitLab CI ou GitHub Actions).
« Arduino CLI apporte une cohérence bienvenue entre le monde du développement embarqué et les pratiques DevOps modernes. Les mêmes commandes construisent un prototype en atelier et un firmware en usine. »
Versions d’Arduino CLI et évolution de l’outil
Arduino CLI évolue régulièrement. Ces mises à jour corrigent des bogues, ajoutent des cibles matérielles et améliorent l’intégration avec les éditeurs et les systèmes d’automatisation. Voici quelques jalons récents.
| Version Arduino CLI | Date de sortie | Intérêt principal pour l’utilisateur |
|---|---|---|
| 1.4.0 | 9 décembre 2025 | Stabilisation des workflows CI, améliorations gRPC et API, meilleure gestion des cœurs de cartes. |
| 1.3.1 | 27 août 2025 | Corrections ciblées sur les installations et le téléchargement des plateformes. |
| 1.3.0 | 11 août 2025 | Nouvelles options de configuration, optimisation de la détection des cartes et performances de compilation. |
| 1.2.2 | 22 avril 2025 | Correctifs de stabilité, ajustements sur l’outil de gestion des bibliothèques. |
Pour un environnement professionnel ou industriel, rester sur une version récente évite des blocages liés aux cœurs de cartes récents ou aux bibliothèques. La CLI sert souvent de brique technique à d’autres outils (IDE, extensions VS Code, scripts d’usine), une mise à jour tardive entraîne rapidement des incompatibilités.
Arduino CLI vs Arduino IDE et PlatformIO : comparaison détaillée
Arduino CLI ne remplace pas forcément l’IDE classique pour chaque usage. Il s’intègre dans un écosystème plus large qui inclut l’IDE, Arduino IDE 2.x, PlatformIO et d’autres solutions.
| Outil | Interface | Profil utilisateur | Forces | Limites |
|---|---|---|---|---|
| Arduino IDE classique | Graphique | Débutants, prototypage rapide | Simplicité, installation directe, peu de configuration. | Pas de débogueur natif, automatisation limitée, difficile à intégrer à des pipelines. |
| Arduino IDE 2.x | Graphique moderne | Utilisateurs intermédiaires | Éditeur plus complet, intégration partielle avec la CLI, meilleure gestion des projets. | Moins flexible que la CLI pour les workflows complexes. |
| Arduino CLI | Ligne de commande | Développeurs avancés, équipes, DevOps | Automatisation, scripts, intégration CI/CD, contrôle précis des versions. | Nécessite une bonne maîtrise du terminal et des variables d’environnement. |
| PlatformIO | Extension VS Code + CLI | Projets multi‑cartes, systèmes complexes | Gestion de multiples plateformes, dépendances avancées, intégration VS Code. | Courbe d’apprentissage plus longue, surcouche par rapport à la CLI Arduino. |
Pour un utilisateur qui vient de l’IDE classique, la transition vers la ligne de commande déstabilise parfois. Les équipes habituées aux pipelines de build (C/C++, Java, web) trouvent au contraire un outil cohérent avec leurs habitudes. Des articles sur l’installation de l’IDE Arduino et sur les nouveautés d’Arduino IDE 2 complètent cette vue d’ensemble.
ArduinoArduino et domotique : automatiser sa maison pour pas cherPlatformIO reste une option pertinente pour uniformiser des projets qui dépassent l’écosystème Arduino. Il s’appuie sur des concepts proches (plateformes, environnements, gestion des bibliothèques) et exploite également une logique de CLI. Pour ceux qui souhaitent structurer des projets complexes dans VS Code, un tour d’horizon de PlatformIO pour Arduino donne un bon point de départ.
Installation d’Arduino CLI sur Windows, macOS et Linux
L’installation d’Arduino CLI se réalise de plusieurs façons : binaire précompilé, gestionnaire de paquets ou script dédié. Le choix dépend de l’OS et des contraintes de l’environnement (accès internet, droits administrateur, automatisation).
Installation rapide par binaire
La méthode la plus directe consiste à télécharger le binaire correspondant à votre système (Windows, macOS, Linux) depuis la page officielle Arduino, puis à l’ajouter au PATH. Cette approche convient bien pour un poste individuel ou pour un test initial.
Sur Linux ou macOS, l’utilisation d’un terminal permet de placer le binaire dans un répertoire déjà présent dans le PATH (par exemple /usr/local/bin ou ~/bin). Sous Windows, l’ajout à la variable d’environnement PATH se gère via les paramètres système.
arduino-cli renvoie « commande introuvable », le problème se situe presque toujours au niveau des variables d’environnement.Installation via gestionnaires de paquets
Sur certaines distributions Linux, Arduino CLI se récupère via apt, dnf ou d’autres gestionnaires. Sur macOS, Homebrew offre une formule pratique. Cette installation facilite les mises à jour, ce qui reste appréciable quand plusieurs projets dépendent de la CLI.
Dans des environnements verrouillés (entreprise, laboratoire), l’outil s’installe parfois via un dépôt interne ou un gestionnaire comme Ansible, Chef ou Puppet. Dans ce cas, la version de la CLI est généralement fixée au niveau de l’infrastructure.
Configurations spécifiques et erreurs courantes
Plusieurs difficultés remontent régulièrement :
- Variables d’environnement mal configurées : PATH incomplet, conflit entre plusieurs installations de la CLI.
- Dépendances manquantes : modules comme
pyserialou outils système nécessaires à certains drivers. - Droits insuffisants : impossibilité d’accéder au port série sous Linux (groupe
dialoutou équivalent non configuré).
Une fois ces éléments réglés, la commande arduino-cli version confirme que l’outil fonctionne et affiche la version installée.
Configuration de base : fichiers, dossiers et cores de cartes
Avant tout usage, Arduino CLI a besoin d’une configuration minimale. L’outil stocke les paramètres dans un fichier YAML (souvent nommé arduino-cli.yaml) qui définit le schéma de dossiers, les URL additionnelles de gestionnaire de cartes et d’autres options.
Structure de configuration
Une configuration typique contient :
- Le chemin de données (dossiers de packages, cores, index).
- Le chemin des sketchbooks (projets et bibliothèques personnelles).
- Les URL additionnelles de gestionnaire de cartes pour ESP32, ESP8266 ou autres plateformes.
- Les options de proxy en cas de réseau filtré.
Un simple arduino-cli config init génère un fichier de base que l’on adapte ensuite. Cette approche permet de centraliser la configuration et de la versionner avec le projet, ce qui améliore la reproductibilité.
Mise à jour de l’index et installation des cores
Avant la première compilation, la CLI doit télécharger l’index des plateformes. La commande arduino-cli core update-index s’en charge. Ensuite, l’installation d’un core spécifique (par exemple arduino:avr pour les cartes Uno ou Nano) s’effectue avec arduino-cli core install arduino:avr.
Cette étape donne accès à la compilation et au téléversement pour la famille de cartes choisie. D’autres cores, comme ceux de tiers (ESP32, STM32, etc.), s’installent de la même manière après ajout de l’URL dans le fichier de configuration.
Gestion des cartes et des ports série en ligne de commande
Arduino CLI offre une vision détaillée des cartes connectées et de leurs ports. Ce point reste crucial dès que plusieurs boards se trouvent branchées sur la même machine.
Liste des cartes détectées
La commande arduino-cli board list affiche les ports série disponibles, le type de carte détecté (lorsque c’est possible) et les identifiants nécessaires au téléversement. Cette liste sert de base pour choisir le bon port sur une machine partagée ou en laboratoire.
D’autres sous‑commandes permettent d’obtenir des informations détaillées sur un modèle particulier, comme les cartes supportées par un core donné ou les options de compilation spécifiques (vitesse de port, fréquence CPU, etc.).
Sélection de la carte et du FQBN
Pour compiler et téléverser, Arduino CLI utilise un identifiant appelé FQBN (Fully Qualified Board Name), par exemple arduino:avr:uno. Ce FQBN précise la carte cible dans le core installé. La commande de compilation inclut cet identifiant, ce qui garantit une correspondance claire entre code et matériel.
Dans un script, garder les FQBN en variables ou en configuration permet d’éviter les erreurs de saisie et de standardiser la cible entre développeurs.
Compilation d’un sketch Arduino avec la CLI
La compilation représente le cœur de l’outil. Arduino CLI reproduit la chaîne de build de l’IDE en ligne de commande, avec la possibilité d’ajuster finement les paramètres.
Structure du sketch et organisation des fichiers
Un sketch se compose d’un fichier .ino principal et, si besoin, de fichiers .h et .cpp. Arduino CLI respecte cette structure, mais permet aussi d’organiser le code selon une arborescence plus proche de celle d’un projet C++ classique, ce qui intéresse particulièrement les ingénieurs habitués à ce langage.
La commande arduino-cli compile prend en argument le chemin du sketch et le FQBN de la carte cible. Des options supplémentaires contrôlent la verbosité, l’activation de la compilation optimisée ou la génération d’artefacts spécifiques.
Options de compilation avancées
Les options les plus utilisées incluent :
- Mode verbeux pour inspecter les commandes
gccinvoquées. - Sortie binaire dans un dossier précis afin d’archiver les firmwares générés.
- Définition de macros de préprocesseur pour activer des fonctions conditionnelles.
Cette maîtrise fine de la compilation rapproche les projets Arduino des pratiques classiques de développement C/C++ et aide à diagnostiquer les problèmes de taille de binaire, de warnings ou d’incompatibilités entre bibliothèques.
Téléversement du firmware et scénarios de déploiement
Une fois le binaire généré, Arduino CLI téléverse le firmware sur la carte via la commande arduino-cli upload. L’outil gère la sélection du port, la vitesse de communication et certains protocoles spécifiques selon le core utilisé.
Mode interactif vs scripts automatisés
Sur un poste de développement, la combinaison compile + upload se réalise souvent en deux commandes successives ou via une seule commande avec option de compilation intégrée. En mode scripté, ces étapes s’enchaînent dans un batch, un script shell ou un pipeline CI.
La possibilité de cibler un port précis ou de laisser la CLI détecter automatiquement la carte couvre les scénarios habituels : développement individuel, banc de test avec plusieurs cartes, ou flasher une série de cartes dans un atelier.
Gestion des erreurs de téléversement
Les échecs de téléversement proviennent fréquemment d’un port série verrouillé par un autre programme, d’un driver manquant ou d’une incompatibilité de bootloader. Le mode verbeux de la CLI fournit les messages renvoyés par l’outil de bas niveau (avrdude, esptool, etc.), ce qui aide au diagnostic.
Dans un contexte industriel, intégrer ces erreurs dans un système de logs ou d’alertes (par exemple via un pipeline CI) assure une surveillance régulière de la qualité des déploiements de firmware.
Gestion des bibliothèques avec Arduino CLI
La CLI inclut un gestionnaire de bibliothèques complet. Il installe, met à jour et liste les dépendances sans passer par l’interface graphique, ce qui facilite le versionnement et l’automatisation.
Installation et mise à jour des librairies
Les commandes de gestion des bibliothèques permettent :
- d’installer une bibliothèque par son nom ou son identifiant exact ;
- de mettre à jour toutes les bibliothèques installées ou une sélection précise ;
- de lister les bibliothèques disponibles et celles déjà présentes dans le système.
Cette approche offre un contrôle précis des versions, essentiel dès qu’un même projet doit rester compilable plusieurs années après sa création.
Versionnement des dépendances
De nombreux développeurs ajoutent à leur dépôt un fichier décrivant les bibliothèques nécessaires, parfois sous forme de simple liste ou de script de réinstallation. Couplée à Arduino CLI, cette méthode garantit que le projet reste reproductible sur un nouveau poste, un conteneur Docker ou un serveur de build.
ArduinoPiloter un relais 230 V avec Arduino en sécurité : 5 erreurs à éviterDans des environnements plus structurés, une surcouche de gestion de dépendances (Makefile, scripts Python, outils internes) orchestre l’installation des bibliothèques avant la compilation. Arduino CLI fournit alors les primitives d’installation et de mise à jour.
Intégration avec VS Code, Makefiles et workflows DevOps
Arduino CLI s’insère facilement dans des environnements de développement riches, en particulier ceux qui reposent sur VS Code, des Makefiles ou des pipelines de build automatisés.
VS Code et extensions spécifiques
De nombreux développeurs utilisent VS Code comme éditeur principal. Deux stratégies dominent :
- utiliser l’extension Arduino officielle ou des extensions tierces qui appellent arduino-cli en arrière‑plan ;
- configurer des tâches VS Code customisées qui invoquent directement les commandes de compilation et de téléversement.
Cette intégration offre l’édition de code avancée (IntelliSense, refactoring, navigation) tout en gardant la robustesse de la chaîne de build Arduino. Pour ceux qui souhaitent basculer vers un écosystème plus large, l’article sur PlatformIO dédié à Arduino explore une alternative orientée multi‑plateforme.
Makefiles, scripts et pipelines CI/CD
Arduino CLI se prête bien à une invocation depuis un Makefile ou un script shell. Ces outils orchestrent la compilation, l’installation des bibliothèques, la génération de binaires et le téléversement. Ils s’intègrent ensuite dans des workflows CI/CD (GitHub Actions, GitLab CI, Jenkins, Azure DevOps, etc.).
Des serveurs d’intégration continue utilisent la CLI pour :
- valider qu’un commit compile sur toutes les cibles supportées ;
- générer des binaires versionnés pour chaque release ;
- exécuter des tests automatisés sur bancs de cartes via des scripts supplémentaires.
Arduino Cloud CLI, API gRPC et intégrations avancées
Au‑delà de la commande locale, l’écosystème Arduino inclut Arduino Cloud CLI, des APIs gRPC et même des modules d’intégration en Go. Ces briques permettent de construire des solutions plus sophistiquées autour de la CLI.
Arduino Cloud CLI
Arduino Cloud CLI relie la ligne de commande au cloud Arduino. Elle automatise :
- la gestion de flottes de cartes connectées ;
- le déploiement de firmwares depuis un environnement distant ;
- la configuration d’objets connectés, variables cloud, dashboards.
Dans un projet IoT, cette approche offre un prolongement naturel de la CLI locale vers une infrastructure distante où les cartes restent accessibles même lorsqu’elles ne sont plus physiquement branchées sur le poste de développement.
API gRPC et module Go
Arduino CLI expose également une API gRPC. Cette interface permet à des programmes externes de piloter la CLI en tant que service : création d’IDE personnalisés, plugins spécialisés, automatisations sur mesure dans des environnements hétérogènes.
Un module Go facilite l’intégration de la CLI dans des outils écrits dans ce langage. Des équipes construisent ainsi des dashboards internes, des interfaces web ou des scripts évolués qui orchestrent le cycle complet : installation des cores, compilation, téléversement et collecte de logs.
« La CLI devient alors un moteur de build embarqué, encapsulé dans des services plus larges, plutôt qu’un simple outil de terminal. »
Débogage, limites actuelles et matériel complémentaire
Le débogage représenterait un axe clé pour de nombreux projets professionnels. L’IDE classique ne propose qu’un suivi via la console série, tandis qu’Arduino IDE Pro (version 0.1.0) introduit des fonctions de débogage encore limitées.
Debug matériel et contraintes
Le véritable débogage pas à pas sur microcontrôleur suppose un matériel additionnel (sondes, adaptateurs, interfaces JTAG ou SWD selon la cible). Arduino CLI s’insère dans ces workflows, mais ne remplace pas ces outils spécialisés. Elle génère le firmware et coordonne parfois l’appel à des utilitaires de debug, sans gérer directement l’interface matérielle.
Pour la plupart des projets, le débogage passe encore par :
- l’utilisation intensive de la console série ;
- l’ajout de logs conditionnels dans le code ;
- l’analyse des timings via des oscilloscopes ou analyseurs logiques.
Rôle d’IDE Pro et autres solutions
Arduino IDE Pro tente d’introduire une gestion multi‑fichiers plus souple et un début de débogage. Cependant, son état précoce et le besoin en matériel spécialisé limitent encore son adoption. Certaines équipes optent pour des alternatives comme PlatformIO, qui intègre des sondes de debug matériel plus largement supportées selon les plateformes.
Dans ce contexte, Arduino CLI garde un rôle de pilote de build robuste, pendant que les outils de debug se concentrent sur l’exécution et l’inspection du code.
Quels profils tirent le meilleur parti d’Arduino CLI ?
Arduino CLI s’adresse particulièrement aux développeurs et ingénieurs qui :
- travaillent en équipe et versionnent leur code sous Git ;
- mettent en place des processus CI/CD ou des builds reproductibles ;
- gèrent plusieurs cartes ou plateformes matérielles dans un même projet ;
- veulent centraliser la configuration des cores, bibliothèques et versions de firmware.
Les débutants restent plus à l’aise avec l’IDE graphique, qui offre une expérience immédiate et visuelle. Au fil de la progression, la transition vers la CLI ouvre l’accès à des pratiques de développement plus structurées, déjà familières dans le monde du logiciel classique.
