Installer PlatformIO avec VS Code : Arduino, ESP32 et Pico
Installer PlatformIO dans VS Code : extension, platformio.ini pour Uno, ESP32 et Pico, lib_deps, téléversement, moniteur série et migration depuis l'IDE Arduino.
Installer PlatformIO consiste à ajouter une seule extension à l'éditeur VS Code pour programmer des cartes comme l'Arduino Uno, l'ESP32 et le Raspberry Pi Pico depuis le même environnement professionnel. En bref : installe VS Code, cherche PlatformIO IDE dans l'onglet Extensions et installe-la, attends que les outils nécessaires se téléchargent au premier lancement, puis crée un nouveau projet depuis l'écran PIO Home en choisissant ta carte. Le reste se passe dans un petit fichier de configuration nommé platformio.ini : la carte, le framework, les bibliothèques et la vitesse du port série y sont écrits.
L'IDE Arduino est un excellent outil pour apprendre, mais tu sens ses limites quand le projet grandit : la complétion de code est basique, les bibliothèques sont communes à tous les projets, une mise à jour de bibliothèque peut casser un ancien projet, et le réglage de la carte n'est pas sauvegardé avec le projet. PlatformIO résout ces problèmes. Dans ce guide, tu vas faire l'installation pas à pas, créer ton premier projet, déclarer trois cartes différentes dans un seul projet avec platformio.ini, ajouter une bibliothèque, téléverser le code, ouvrir le moniteur série et migrer des projets existants de l'IDE Arduino. Dans la dernière partie, on compare les deux outils de façon neutre pour t'aider à choisir.

Qu'est-ce que PlatformIO et comment ça marche ?
PlatformIO est un écosystème de développement open source pour les systèmes embarqués. Au cœur, il y a un outil en ligne de commande écrit en Python, PlatformIO Core ; l'extension VS Code le rend pratique avec des boutons, des menus et l'écran PIO Home. Quand tu compiles un projet, PlatformIO lit d'abord platformio.ini, puis télécharge depuis son dépôt le compilateur nécessaire (avr-gcc pour l'Uno, la chaîne d'outils Xtensa pour l'ESP32, arm-none-eabi-gcc pour le Pico), le framework et les bibliothèques, puis compile ton code. Ces paquets ne sont téléchargés qu'une fois et stockés dans le dossier .platformio de ton répertoire utilisateur ; les projets suivants les réutilisent. Connaître les notions ci-dessous te facilitera beaucoup la lecture du fichier :
| Notion | Signification | Exemple |
|---|---|---|
| Platform (plateforme) | Paquet de compilateurs et d'outils de téléversement pour une famille de microcontrôleurs | atmelavr, espressif32, raspberrypi |
| Board (carte) | Carte précise au sein de la plateforme ; brochage, fréquence d'horloge et mémoire | uno, nanoatmega328, esp32dev, pico |
| Framework | Infrastructure logicielle sur laquelle tu écris ton code | arduino, espidf |
| Environnement (env) | Section qui regroupe plateforme, carte, framework et réglages supplémentaires | [env:uno] |
| Bibliothèque | Paquet de code prêt à l'emploi ajouté au projet avec lib_deps | adafruit/DHT sensor library |
| PIO Home | Écran pour ouvrir un projet, chercher des cartes et des bibliothèques | Icône de maison dans la barre d'état |
Installer PlatformIO pas à pas
- Télécharge et installe Visual Studio Code depuis le site officiel. Sous Windows, cocher Add to PATH pendant l'installation facilite l'usage du terminal.
- Ouvre VS Code et clique sur l'onglet Extensions à gauche, ou utilise le raccourci Ctrl+Maj+X (Cmd+Maj+X sur macOS).
- Tape PlatformIO IDE dans la zone de recherche et installe l'extension publiée par PlatformIO avec le bouton Install. L'extension C/C++ nécessaire est ajoutée automatiquement.
- Une notification « Installing PlatformIO Core » apparaît en bas à droite. Selon ta connexion, cette étape prend quelques minutes ; ne ferme pas VS Code pendant ce temps.
- À la fin, VS Code te demande de redémarrer. Après le redémarrage, l'icône PlatformIO apparaît sur le côté gauche et l'icône de maison dans la barre d'état en bas.
- Clique sur l'icône de maison pour ouvrir l'écran PIO Home. Si cet écran s'affiche sans problème, l'installation est terminée.
Créer un premier projet et structure des dossiers
Dans PIO Home, clique sur New Project. Dans la fenêtre qui s'ouvre, donne un nom au projet (par exemple blink-uno), tape Arduino Uno dans le champ Board et choisis-le dans la liste, laisse Arduino comme Framework et choisis l'emplacement. Quand tu cliques sur Finish, PlatformIO télécharge pour la première fois le paquet de plateforme de ta carte ; le premier projet peut donc prendre quelques minutes, les suivants s'ouvrent en quelques secondes. Une fois le projet créé, VS Code ouvre le dossier et tu vois cette structure :
| Dossier / fichier | À quoi ça sert ? |
|---|---|
| platformio.ini | Le cœur du projet : réglages de carte, framework, bibliothèques et port |
| src/ | Ton code source ; le programme démarre dans main.cpp |
| include/ | Tes propres fichiers d'en-tête (.h) |
| lib/ | Bibliothèques locales propres au projet, ajoutées à la main (chacune dans un sous-dossier) |
| test/ | Dossier réservé aux tests unitaires |
| .pio/ | Résultats de compilation et bibliothèques téléchargées ; recréé s'il est supprimé |
| .vscode/ | Réglages de VS Code et d'IntelliSense ; généré automatiquement |
Qu'est-ce que le fichier platformio.ini ?
platformio.ini est un simple fichier texte au format INI. Chaque section commençant par [env:nom] entre crochets définit un environnement de compilation. Ce que tu choisis dans le menu Outils de l'IDE Arduino (carte, vitesse du port), tu l'écris ici en texte ; ainsi, quand tu déplaces le projet sur un autre ordinateur ou le donnes à un ami, les réglages suivent avec le code. Les lignes qui commencent par un point-virgule sont des commentaires. Voici le fichier créé pour l'Uno, une fois la vitesse du moniteur série ajoutée :
1; PlatformIO proje ayarları / PlatformIO project settings
2[env:uno]
3platform = atmelavr
4board = uno
5framework = arduino
6; Seri monitör hızı, Serial.begin ile aynı olmalı / Monitor speed, must match Serial.begin
7monitor_speed = 115200| Réglage | Rôle | Exemple de valeur |
|---|---|---|
| platform | Paquet de plateforme à utiliser ; la version peut aussi être figée | atmelavr, [email protected] |
| board | Identifiant de la carte | uno, megaatmega2560, esp32dev, pico |
| framework | Framework logiciel | arduino |
| monitor_speed | Vitesse du moniteur série (9600 par défaut) | 115200 |
| upload_port | Port de téléversement (détecté automatiquement si laissé vide) | COM5, /dev/ttyUSB0 |
| upload_speed | Vitesse de téléversement en bauds (surtout pour les cartes ESP) | 921600 |
| lib_deps | Bibliothèques à télécharger automatiquement | adafruit/DHT sensor library@^1.4.4 |
| build_flags | Options et macros supplémentaires pour le compilateur | -D LED_PIN=2 |
| monitor_filters | Filtres appliqués à la sortie du moniteur série | time, esp32_exception_decoder |
Premier code : main.cpp et la différence avec Arduino.h
Le fichier main.cpp du dossier src est l'équivalent du fichier .ino de l'IDE Arduino, mais avec deux différences importantes. Premièrement, tout en haut du fichier, il faut une ligne #include qui ajoute l'en-tête Arduino.h ; l'IDE Arduino l'ajoute tout seul en arrière-plan, pas PlatformIO. Deuxièmement, un fichier .cpp suit les vraies règles du C++ : le compilateur doit connaître une fonction avant que tu l'appelles. L'IDE Arduino génère les prototypes de fonctions à ta place ; avec PlatformIO, soit tu définis la fonction avant de l'utiliser, soit tu écris un prototype d'une ligne en haut du fichier. L'exemple ci-dessous est un programme blink qui fonctionne sur l'Uno, l'ESP32 et le Pico :
1#include <Arduino.h>
2
3// LED_PIN platformio.ini'den gelebilir / LED_PIN may come from platformio.ini
4#ifndef LED_PIN
5#define LED_PIN LED_BUILTIN // Uno: 13, Pico: GP25
6#endif
7
8void blinkLed(int count); // prototip / prototype
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(LED_PIN, OUTPUT);
13 Serial.println("PlatformIO hazir / ready");
14}
15
16void loop() {
17 blinkLed(3);
18 delay(1000);
19}
20
21void blinkLed(int count) {
22 for (int i = 0; i < count; i++) {
23 digitalWrite(LED_PIN, HIGH);
24 delay(150);
25 digitalWrite(LED_PIN, LOW);
26 delay(150);
27 }
28 Serial.print("Yanip sondu / Blinked: ");
29 Serial.println(count);
30}Compiler, téléverser et utiliser le moniteur série
| Action | Barre d'état / menu | Commande du terminal |
|---|---|---|
| Compiler (Build) | Icône de coche | pio run |
| Téléverser (Upload) | Flèche vers la droite | pio run -t upload |
| Téléverser et ouvrir le moniteur | Menu PlatformIO > Upload and Monitor | pio run -t upload -t monitor |
| Moniteur série | Icône de prise | pio device monitor |
| Nettoyer | Icône de corbeille | pio run -t clean |
| Lister les ports | PIO Home > Devices | pio device list |
| Compiler un environnement précis | Sélecteur d'environnement (env:...) | pio run -e esp32dev |
| Installer une bibliothèque | PIO Home > Libraries | pio pkg install -l "adafruit/DHT sensor library" |
Pour que le moniteur série fonctionne correctement, la valeur monitor_speed de platformio.ini doit être identique à la vitesse de Serial.begin() dans le code ; sinon tu vois des caractères incompréhensibles à l'écran. PlatformIO trouve généralement seul la carte connectée, mais si l'ordinateur a plusieurs périphériques série, il peut essayer de téléverser sur le mauvais port. Dans ce cas, liste les ports avec la commande pio device list et écris le bon dans les lignes upload_port et monitor_port. Si le moniteur série de l'IDE Arduino ou un autre programme de terminal garde le port ouvert, le téléversement s'arrête avec l'erreur « Access is denied » ou « Resource busy » ; il suffit de fermer ce programme. Pour mieux connaître le moniteur série lui-même, jette aussi un œil à l'article Arduino Serial Monitor. La commande pio fonctionne toujours dans le terminal PlatformIO Core CLI ouvert depuis le menu PlatformIO.
Déclarer Uno, ESP32 et Pico dans un seul projet
L'un des points forts de PlatformIO est de pouvoir compiler le même code pour plusieurs cartes. Tu écris une section [env:...] distincte pour chaque carte ; si tu mets les réglages communs dans la section sans nom [env], tous les environnements en héritent. Le tableau suivant résume les valeurs de base de trois cartes populaires :
| Valeur | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| platform | atmelavr | espressif32 | raspberrypi |
| board | uno | esp32dev | pico |
| framework | arduino | arduino | arduino (cœur Arduino Mbed) |
| LED intégrée | D13 | GPIO 2 (sur la plupart des cartes DevKit) | GP25 |
| Méthode de téléversement | USB-série et bootloader | USB-série et esptool | USB et mode BOOTSEL |
| monitor_speed typique | 9600 ou 115200 | 115200 | 115200 |
1[platformio]
2; Varsayılan ortam / Default environment
3default_envs = uno
4
5; Tüm ortamlarda ortak ayarlar / Settings shared by all environments
6[env]
7framework = arduino
8monitor_speed = 115200
9
10[env:uno]
11platform = atmelavr
12board = uno
13
14[env:esp32dev]
15platform = espressif32
16board = esp32dev
17upload_speed = 921600
18monitor_filters = esp32_exception_decoder
19; Dahili LED GPIO 2 / Onboard LED on GPIO 2
20build_flags = -D LED_PIN=2
21
22[env:pico]
23platform = raspberrypi
24board = picoLa ligne default_envs détermine quel environnement utilisent les boutons de compilation et de téléversement de la barre d'état ; si tu ne l'écris pas, PlatformIO compile tous les environnements du fichier l'un après l'autre. Tu peux passer à une autre carte à tout moment avec le sélecteur d'environnement de la barre d'état, ou téléverser directement sur l'ESP32 en tapant pio run -e esp32dev -t upload dans le terminal. L'option -D LED_PIN=2 de l'environnement ESP32 définit la macro LED_PIN du code ; comme cette option n'existe pas pour l'Uno et le Pico, le code retombe sur la valeur de LED_BUILTIN (13 et 25). Ainsi, un seul main.cpp fonctionne sur les trois cartes sans aucune modification. Pour voir rapidement le brochage des cartes, tu peux utiliser l'outil pinout.
Réglages PlatformIO pour l'ESP32
Les cartes ESP32 sont programmées avec esptool dans PlatformIO, comme dans l'IDE Arduino. upload_speed = 921600 réduit nettement le temps de téléversement ; si ton câble est long ou de mauvaise qualité et que tu as des erreurs, descends à 460800 ou 115200. Le filtre esp32_exception_decoder transforme la pile d'adresses incompréhensible affichée dans le moniteur série quand la carte plante en noms de fonctions et numéros de ligne ; il est très précieux pour trouver les erreurs Guru Meditation. Si le téléversement reste bloqué à l'étape « Connecting... », maintiens le bouton BOOT de la carte enfoncé et relâche-le quand le téléversement démarre ; les solutions détaillées sont dans l'article ESP32 Failed to Connect. Un autre détail à connaître est la version du cœur : la plateforme officielle espressif32 de PlatformIO a longtemps utilisé la version 2.x du cœur Arduino-ESP32 ; si tu as besoin d'API propres à la 3.x, tu peux passer à la plateforme pioarduino maintenue par la communauté. Tu vois quel cœur est utilisé grâce à la version de framework-arduinoespressif32 sur la ligne PACKAGES au début de la sortie de compilation. Si tu veux que ton code compile avec les deux versions, tu peux les distinguer avec la macro ESP_ARDUINO_VERSION_MAJOR.
Raspberry Pi Pico et PlatformIO
Avec le réglage board = pico, la plateforme officielle raspberrypi utilise le cœur RP2040 officiel d'Arduino basé sur Mbed OS. Beaucoup d'utilisateurs préfèrent le cœur arduino-pico d'Earle Philhower, qui offre plus de fonctionnalités et une meilleure compatibilité avec les bibliothèques ; dans PlatformIO, il s'utilise avec un paquet de plateforme séparé maintenu par la communauté et le réglage board_build.core = earlephilhower. Quel que soit le cœur choisi, au premier téléversement tu devras peut-être brancher le Pico à l'USB en maintenant le bouton BOOTSEL enfoncé ; la carte apparaît sur l'ordinateur comme un lecteur nommé RPI-RP2, et après le téléversement du programme, PlatformIO la redémarre tout seul. Pour les téléversements suivants, le bouton n'est le plus souvent plus nécessaire. Note importante : PlatformIO ne prend pas en charge MicroPython. Si tu veux programmer le Pico en MicroPython, tu dois utiliser un éditeur comme Thonny ; pour les détails, consulte les articles Bases de MicroPython et Qu'est-ce que le Raspberry Pi Pico ?.
Ajouter des bibliothèques : lib_deps
Dans PlatformIO, les bibliothèques ne sont pas installées pour tout l'ordinateur mais séparément pour chaque projet. La méthode la plus propre est d'ajouter une ligne lib_deps à platformio.ini : à la première compilation, PlatformIO télécharge la bibliothèque depuis le registre et la place dans le dossier .pio/libdeps/. Tu peux aussi chercher le nom exact de la bibliothèque dans l'onglet Libraries de PIO Home et l'ajouter avec le bouton Add to Project ; ce bouton écrit la ligne lib_deps à ta place. Voici un exemple qui connecte un capteur DHT11 à la broche D2 de l'Uno ; pour le câblage du capteur, regarde l'article Capteur de température et d'humidité DHT11.
1[env:uno]
2platform = atmelavr
3board = uno
4framework = arduino
5monitor_speed = 115200
6; Kütüphaneler ilk derlemede otomatik iner / Libraries download on first build
7lib_deps =
8 adafruit/DHT sensor library@^1.4.4
9 adafruit/Adafruit Unified Sensor@^1.1.91#include <Arduino.h>
2#include <DHT.h>
3
4#define DHT_PIN 2 // Uno D2 pini / Uno pin D2
5#define DHT_TYPE DHT11
6
7DHT dht(DHT_PIN, DHT_TYPE);
8
9void setup() {
10 Serial.begin(115200);
11 dht.begin();
12}
13
14void loop() {
15 delay(2000); // DHT11 en fazla 1 Hz / DHT11 max 1 Hz
16 float h = dht.readHumidity();
17 float t = dht.readTemperature();
18 if (isnan(h) || isnan(t)) {
19 Serial.println("Sensor okunamadi / Read failed");
20 return;
21 }
22 Serial.print("Sicaklik / Temp: ");
23 Serial.print(t, 1);
24 Serial.print(" C Nem / Hum: ");
25 Serial.print(h, 0);
26 Serial.println(" %");
27}Dans l'écriture des versions, ^1.4.4 autorise les versions 1.4.4 et supérieures mais inférieures à 2.0.0 ; ~1.4.4 n'accepte que les correctifs 1.4.x ; si tu écris seulement 1.4.4, la version est entièrement figée. Figer la version garantit que, quand tu rouvriras le projet dans un an, le même code compilera de la même façon. Si tu mets une bibliothèque absente du registre ou écrite par toi dans le dossier lib du projet, sous la forme d'un sous-dossier à son nom, PlatformIO la trouve automatiquement. Si tu veux comparer avec la logique des bibliothèques de l'IDE Arduino, tu peux lire l'article Ajouter une bibliothèque Arduino.
Migrer un projet de l'IDE Arduino vers PlatformIO
- Dans PIO Home, crée un nouveau projet et choisis la même carte que celle que tu utilisais dans l'IDE Arduino.
- Colle le contenu du fichier .ino dans src/main.cpp ; ajoute les autres onglets .ino du même dossier à la fin de main.cpp, et copie les fichiers .h et .cpp dans le dossier src.
- Ajoute en haut du fichier la ligne #include pour Arduino.h.
- Pour chaque fonction écrite en dehors de setup() et loop(), écris un prototype en haut du fichier.
- Trouve les bibliothèques que tu utilises dans PIO Home > Libraries et ajoute-les à lib_deps ; si tu écris le numéro de version de l'IDE Arduino, tu obtiens le même comportement.
- Écris la vitesse de Serial.begin() dans la ligne monitor_speed et compile le projet. Corrige un par un les avertissements restants dans la liste d'erreurs.
Sinon, tu peux importer directement le dossier existant avec le bouton Import Arduino Project de PIO Home. PlatformIO convertit lui-même les fichiers .ino du dossier src en .cpp pendant la compilation et essaie de générer les prototypes. Mais comme cette conversion peut se tromper sur du code complexe et qu'IntelliSense ne fonctionne pas à plein rendement sur les fichiers .ino, passer à main.cpp est plus sain à long terme. Si tu as du mal à interpréter les messages de compilation, les explications de l'article Erreurs de compilation Arduino valent aussi pour PlatformIO.
IDE Arduino ou PlatformIO ?
| Critère | IDE Arduino 2.x | PlatformIO (VS Code) |
|---|---|---|
| Installation | Un seul paquet, quelques minutes | VS Code et extension ; les outils se téléchargent à la première installation |
| Complétion de code | Basique | IntelliSense avancé, aller à la définition, renommage en masse |
| Réglage de la carte | Dans le menu Outils, non sauvegardé avec le projet | Dans platformio.ini, transporté avec le projet |
| Bibliothèques | Communes à tout l'ordinateur | Séparées par projet, version figeable |
| Plusieurs cartes | À changer dans le menu à chaque fois | Plusieurs environnements dans un seul projet |
| Structure des fichiers | .ino ; le nom du dossier doit être identique à celui du fichier | src, include, lib ; .cpp et .h standard |
| Prototypes de fonctions | Générés automatiquement | Écrits à la main (automatiques à l'import d'un .ino) |
| Suivi de version avec Git | Possible, mais les réglages de carte restent en dehors | Facile ; tout est suivi sauf le dossier .pio |
| Débogage et tests | Débogueur sur certaines cartes | Prise en charge du débogueur (debug probe) et des tests unitaires |
| Adapté aux débutants | Très élevé | Moyen ; demande un court temps d'adaptation |
En résumé, si tu allumes ta première LED ou fais un petit projet scolaire de quelques fichiers, l'IDE Arduino suffit et prête moins à confusion. Dès qu'il est question de plusieurs cartes, de code en plusieurs fichiers, de suivi de version avec Git ou de travail en équipe, PlatformIO te fait gagner un temps précieux. Les deux outils ne s'excluent pas ; tu peux les utiliser ensemble sur le même ordinateur. Si tu n'as pas encore installé l'IDE Arduino, tu peux commencer par l'article Installation de l'IDE Arduino.
Erreurs fréquentes et solutions
| Symptôme | Cause possible | Solution |
|---|---|---|
| 'xyz' was not declared in this scope | Prototype de fonction manquant | Écris le prototype avant setup() ou remonte la fonction |
| fatal error: DHT.h: No such file or directory | La bibliothèque n'est pas dans lib_deps ou a été ajoutée à un autre environnement | Ajoute la bibliothèque dans la bonne section [env] et recompile |
| Caractères incompréhensibles dans le moniteur série | monitor_speed différent de la vitesse de Serial.begin() | Mets les deux valeurs identiques (ex. 115200) |
| La carte n'apparaît pas, aucun port | Câble de charge seul ou pilote CH340/CP2102 manquant | Utilise un câble de données, installe le pilote, vérifie avec pio device list |
| Access is denied / Resource busy | Le port est ouvert dans un autre programme | Ferme le moniteur série de l'IDE Arduino et les autres terminaux |
| ESP32 : Failed to connect, Wrong boot mode | La carte n'est pas passée en mode téléchargement | Lance le téléversement en maintenant le bouton BOOT enfoncé |
| Le téléversement ne démarre pas sur le Pico | La carte n'est pas en mode BOOTSEL | Branche-la en maintenant BOOTSEL et vérifie que le lecteur RPI-RP2 apparaît |
| Sous Linux, Permission denied: /dev/ttyUSB0 | Règle udev ou droit utilisateur manquant | Installe le fichier 99-platformio-udev.rules, ajoute ton utilisateur au groupe dialout |
| Sous Windows, la compilation s'arrête avec des erreurs de chemin incompréhensibles | Caractères accentués ou espace dans le nom d'utilisateur | Déplace le dossier core vers C:\platformio avec PLATFORMIO_CORE_DIR |
| Bloqué à l'étape Installing PlatformIO Core | Problème de connexion, d'antivirus ou de Python | Redémarre VS Code, consulte le journal Output > PlatformIO |
Premiers projets à tester avec PlatformIO
- Blink multi-cartes : téléverse le projet à trois environnements ci-dessus sur l'Uno, l'ESP32 et le Pico l'un après l'autre pour comprendre la logique du sélecteur d'environnement.
- Journal de capteur horodaté : affiche les données du DHT11 avec l'heure dans le moniteur série grâce au réglage monitor_filters = time.
- Serveur web Wi-Fi : dans le projet de serveur web ESP32, découpe le code en plusieurs fichiers .cpp et .h pour obtenir une structure propre.
- Mise à jour sans fil : avec l'OTA de l'ESP32, téléverse le code par Wi-Fi en mettant upload_protocol = espota et l'adresse IP de la carte dans upload_port.
- Machine à états : écris la logique d'une machine à états Arduino dans une classe séparée pour profiter de la structure de dossiers de PlatformIO.
- Temporisation sans delay : écris un programme qui exécute plusieurs tâches en même temps avec millis().
Même si installer PlatformIO prend un peu plus de temps que l'IDE Arduino au début, comme le fichier platformio.ini garde tous les réglages du projet au même endroit, il devient avec le temps l'outil qui te fait gagner le plus de temps. Une fois l'installation terminée, compile et téléverse d'abord un simple projet de LED, puis passe aux projets avec bibliothèques et multi-cartes. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas de câblage et codes, des projets pour allumer une LED, des projets de démarrage ESP32 et Pico, ainsi que des projets de capteurs comme le DHT11 et le HC-SR04 ; tu peux les essayer en copiant ces codes directement dans ton propre projet PlatformIO.
Questions fréquentes
PlatformIO est-il gratuit ?
Oui. PlatformIO Core et l'extension PlatformIO IDE pour VS Code sont open source et gratuits. Que ce soit pour un loisir, l'école ou un projet commercial, tu n'as aucune licence à payer pour les définitions de cartes, le gestionnaire de bibliothèques, la compilation et le téléversement.
Le code de l'IDE Arduino fonctionne-t-il dans PlatformIO ?
Oui, car avec framework = arduino, ce sont le même cœur Arduino et les mêmes fonctions qui sont utilisés. Il te suffit de déplacer le code dans src/main.cpp, d'ajouter en haut la ligne include d'Arduino.h, d'écrire les prototypes de fonctions et d'ajouter tes bibliothèques à lib_deps.
Pourquoi l'installation de PlatformIO est-elle si longue ?
À la première installation, PlatformIO Core, l'environnement Python et les outils de base sont téléchargés ; dans le premier projet, le compilateur et le framework de ta carte le sont aussi. Comme les paquets ESP32 peuvent peser des centaines de mégaoctets, cela peut prendre 5 à 15 minutes selon ta connexion. Une fois les paquets téléchargés, les projets suivants s'ouvrent vite.
PlatformIO prend-il en charge MicroPython ?
Non, PlatformIO est conçu pour les frameworks basés sur C/C++ comme Arduino et ESP-IDF. Si tu veux programmer un Raspberry Pi Pico ou un ESP32 en MicroPython, utilise un éditeur comme Thonny. Tu peux aussi programmer la même carte avec le framework Arduino dans PlatformIO.
Comment ajouter une bibliothèque dans PlatformIO ?
Le plus simple est d'ouvrir l'onglet Libraries dans PIO Home, de chercher la bibliothèque et de choisir ton projet avec Add to Project. Cela ajoute la ligne lib_deps à platformio.ini et la bibliothèque se télécharge automatiquement à la première compilation. Tes propres bibliothèques peuvent être placées comme sous-dossiers dans le dossier lib du projet.
Comment choisir le port COM dans PlatformIO ?
PlatformIO trouve le plus souvent la carte connectée automatiquement. S'il y a plusieurs périphériques série, tu peux fixer le port avec le sélecteur de port de la barre d'état ou en écrivant les lignes upload_port = COM5 et monitor_port = COM5 dans platformio.ini. Tu vois quels ports sont connectés avec la commande pio device list.
Projets à réaliser après cet article
Voir tous les projets
Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
Le projet d'ouverture de la série Raspberry Pi Pico ! On fait clignoter la LED verte intégrée du Pico pour vérifier que la carte fonctionne : le classique premier essai façon "Hello World". Aucun composant externe, juste le Pico et un câble USB. Le code est écrit en MicroPython, le langage officiellement pris en charge par la Raspberry Pi Foundation.

Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

HC-SR04 Mesure de la distance (affichage en série)
Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

Clignotement de la LED interne de l'ESP32
Faire clignoter la LED bleue intégrée à l'ESP32 DevKit V1. Aucun composant externe n'est nécessaire ! Le premier projet que vous devriez essayer lorsque vous achetez un ESP32. Le GPIO 2 est connecté à la LED interne.

Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
L'étape suivante après la LED intégrée du Pico : brancher une LED externe sur une plaque d'essai et la piloter par la broche GP14. Tu apprends à utiliser n'importe quelle broche GPIO du Pico en sortie, la polarité de la LED (patte longue = anode/+, patte courte = cathode/–) et pourquoi une résistance de limitation (220Ω) est indispensable. Sans elle, trop de courant traverse la LED, qui peut griller.

ESP32 Contrôle de LED avec bouton poussoir (Push)
La LED s'allume lorsque le bouton est enfoncé et s'éteint lorsqu'il est relâché. Montre comment la broche d'entrée numérique de l'ESP32 et la résistance pull-up interne sont utilisées. Grâce au mode INPUT_PULLUP, aucune résistance externe n'est nécessaire.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

