Guides · 13 min de lecture

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.

PlatformIO Arduino Uno
Tu peux programmer des cartes comme l'Arduino Uno, l'ESP32 et le Raspberry Pi Pico avec PlatformIO, depuis le même éditeur et avec un seul fichier de configuration.

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 :

NotionSignificationExemple
Platform (plateforme)Paquet de compilateurs et d'outils de téléversement pour une famille de microcontrôleursatmelavr, espressif32, raspberrypi
Board (carte)Carte précise au sein de la plateforme ; brochage, fréquence d'horloge et mémoireuno, nanoatmega328, esp32dev, pico
FrameworkInfrastructure logicielle sur laquelle tu écris ton codearduino, espidf
Environnement (env)Section qui regroupe plateforme, carte, framework et réglages supplémentaires[env:uno]
BibliothèquePaquet de code prêt à l'emploi ajouté au projet avec lib_depsadafruit/DHT sensor library
PIO HomeÉcran pour ouvrir un projet, chercher des cartes et des bibliothèquesIcône de maison dans la barre d'état

Installer PlatformIO pas à pas

  1. 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.
  2. Ouvre VS Code et clique sur l'onglet Extensions à gauche, ou utilise le raccourci Ctrl+Maj+X (Cmd+Maj+X sur macOS).
  3. 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.
  4. 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.
  5. À 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.
  6. 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.
Si ton nom d'utilisateur Windows contient des caractères spéciaux ou accentués (comme é, è, ç, ş, ğ) ou des espaces, la chaîne d'outils de PlatformIO peut avoir des problèmes avec le chemin C:\Users\<nom>\.platformio et la compilation peut s'arrêter avec des erreurs de chemin incompréhensibles. La solution : ajouter la variable d'environnement système PLATFORMIO_CORE_DIR avec pour valeur un dossier composé uniquement de lettres simples, par exemple C:\platformio. Sous Linux, si l'installation échoue, vérifie d'abord que le paquet python3-venv est installé.

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.iniLe 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 :

C++ (Arduino IDE)
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églageRôleExemple de valeur
platformPaquet de plateforme à utiliser ; la version peut aussi être figéeatmelavr, [email protected]
boardIdentifiant de la carteuno, megaatmega2560, esp32dev, pico
frameworkFramework logicielarduino
monitor_speedVitesse du moniteur série (9600 par défaut)115200
upload_portPort de téléversement (détecté automatiquement si laissé vide)COM5, /dev/ttyUSB0
upload_speedVitesse de téléversement en bauds (surtout pour les cartes ESP)921600
lib_depsBibliothèques à télécharger automatiquementadafruit/DHT sensor library@^1.4.4
build_flagsOptions et macros supplémentaires pour le compilateur-D LED_PIN=2
monitor_filtersFiltres appliqués à la sortie du moniteur sérietime, 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 :

C++ (Arduino IDE)
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}
Si tu vois l'erreur 'blinkLed' was not declared in this scope à la compilation, ce qui manque est presque toujours le prototype. Il te suffit de copier la première ligne de la fonction, sans son corps et avec un point-virgule à la fin, au-dessus de setup(). Si tu as beaucoup de fonctions, il est plus propre de les regrouper dans un fichier .h du dossier include.

Compiler, téléverser et utiliser le moniteur série

ActionBarre d'état / menuCommande du terminal
Compiler (Build)Icône de cochepio run
Téléverser (Upload)Flèche vers la droitepio run -t upload
Téléverser et ouvrir le moniteurMenu PlatformIO > Upload and Monitorpio run -t upload -t monitor
Moniteur sérieIcône de prisepio device monitor
NettoyerIcône de corbeillepio run -t clean
Lister les portsPIO Home > Devicespio device list
Compiler un environnement précisSélecteur d'environnement (env:...)pio run -e esp32dev
Installer une bibliothèquePIO Home > Librariespio 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 :

ValeurArduino UnoESP32 DevKitRaspberry Pi Pico
platformatmelavrespressif32raspberrypi
boardunoesp32devpico
frameworkarduinoarduinoarduino (cœur Arduino Mbed)
LED intégréeD13GPIO 2 (sur la plupart des cartes DevKit)GP25
Méthode de téléversementUSB-série et bootloaderUSB-série et esptoolUSB et mode BOOTSEL
monitor_speed typique9600 ou 115200115200115200
C++ (Arduino IDE)
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 = pico

La 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.

C++ (Arduino IDE)
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.9
C++ (Arduino IDE)
1#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

  1. Dans PIO Home, crée un nouveau projet et choisis la même carte que celle que tu utilisais dans l'IDE Arduino.
  2. 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.
  3. Ajoute en haut du fichier la ligne #include pour Arduino.h.
  4. Pour chaque fonction écrite en dehors de setup() et loop(), écris un prototype en haut du fichier.
  5. 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.
  6. É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èreIDE Arduino 2.xPlatformIO (VS Code)
InstallationUn seul paquet, quelques minutesVS Code et extension ; les outils se téléchargent à la première installation
Complétion de codeBasiqueIntelliSense avancé, aller à la définition, renommage en masse
Réglage de la carteDans le menu Outils, non sauvegardé avec le projetDans platformio.ini, transporté avec le projet
BibliothèquesCommunes à tout l'ordinateurSéparées par projet, version figeable
Plusieurs cartesÀ changer dans le menu à chaque foisPlusieurs environnements dans un seul projet
Structure des fichiers.ino ; le nom du dossier doit être identique à celui du fichiersrc, include, lib ; .cpp et .h standard
Prototypes de fonctionsGénérés automatiquementÉcrits à la main (automatiques à l'import d'un .ino)
Suivi de version avec GitPossible, mais les réglages de carte restent en dehorsFacile ; tout est suivi sauf le dossier .pio
Débogage et testsDébogueur sur certaines cartesPrise en charge du débogueur (debug probe) et des tests unitaires
Adapté aux débutantsTrè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ômeCause possibleSolution
'xyz' was not declared in this scopePrototype de fonction manquantÉcris le prototype avant setup() ou remonte la fonction
fatal error: DHT.h: No such file or directoryLa bibliothèque n'est pas dans lib_deps ou a été ajoutée à un autre environnementAjoute la bibliothèque dans la bonne section [env] et recompile
Caractères incompréhensibles dans le moniteur sériemonitor_speed différent de la vitesse de Serial.begin()Mets les deux valeurs identiques (ex. 115200)
La carte n'apparaît pas, aucun portCâble de charge seul ou pilote CH340/CP2102 manquantUtilise un câble de données, installe le pilote, vérifie avec pio device list
Access is denied / Resource busyLe port est ouvert dans un autre programmeFerme le moniteur série de l'IDE Arduino et les autres terminaux
ESP32 : Failed to connect, Wrong boot modeLa carte n'est pas passée en mode téléchargementLance le téléversement en maintenant le bouton BOOT enfoncé
Le téléversement ne démarre pas sur le PicoLa carte n'est pas en mode BOOTSELBranche-la en maintenant BOOTSEL et vérifie que le lecteur RPI-RP2 apparaît
Sous Linux, Permission denied: /dev/ttyUSB0Règle udev ou droit utilisateur manquantInstalle 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éhensiblesCaractères accentués ou espace dans le nom d'utilisateurDéplace le dossier core vers C:\platformio avec PLATFORMIO_CORE_DIR
Bloqué à l'étape Installing PlatformIO CoreProblème de connexion, d'antivirus ou de PythonRedémarre VS Code, consulte le journal Output > PlatformIO
IntelliSense souligne parfois le code en rouge alors que la compilation réussit. Cela signifie généralement que tu as ouvert un sous-dossier du projet dans VS Code ou que l'index n'est pas à jour. Ouvre toujours le dossier qui contient platformio.ini et lance depuis la palette de commandes (Ctrl+Maj+P) la commande PlatformIO: Rebuild IntelliSense Index.

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.

Voir tous les projets
Clignotement d'une LED
AR-1Débutant

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.

4.6(200)
1246
Clignotement LED avec ESP32
ES-1Débutant

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.

4.7(37)
108
Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
PI-1Débutant

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.

5.0(1)
10
Température et humidité avec DHT11
AR-55Intermédiaire

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…

4.7(47)
83
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

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…

4.6(50)
82
Clignotement de la LED interne de l'ESP32
ES-4Débutant

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.

4.8(29)
54
Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
PI-2Débutant

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.

4.5(2)
7
ESP32 Contrôle de LED avec bouton poussoir (Push)
ES-2Débutant

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.

4.6(36)
57