4201c4

Introduction à PlatformIO

Définition

PlatformIO est un écosystème complet pour le développement embarqué qui s’intègre dans Visual Studio Code. C’est une plateforme professionnelle de développement qui supporte plus de 1000 cartes de développement différentes et plus de 50 plateformes, incluant Arduino, ESP32, STM32, Raspberry Pi Pico, et bien d’autres.

PlatformIO offre un environnement de développement moderne et puissant qui remplace avantageusement l’IDE Arduino traditionnel. Il combine la simplicité d’utilisation d’Arduino avec les fonctionnalités avancées d’un environnement de développement professionnel.

Pourquoi utiliser PlatformIO plutôt que l’IDE Arduino?

PlatformIO présente plusieurs avantages significatifs par rapport à l’IDE Arduino traditionnel:

1. Éditeur de code avancé

2. Gestion de projet professionnelle

3. Gestion des librairies améliorée

4. Outils de débogage

5. Compilation et téléversement optimisés

6. Tests unitaires

7. Intégration continue

8. Environnement professionnel

9. Documentation et communauté

Installation de l’extension PlatformIO IDE sous VS Code

PlatformIO s’installe sous VS Code en y ajoutant l’extension ‘PlatformIO IDE’:

Installation PlatformIO

👉 Premiers pas

1 - Créer un nouveau projet sous PlatformIO

Nouveau projet PlatformIO

Nommer le projet et choisir la platforme

Configuration projet

1.1 - Examiner la structure de départ

Structure projet

La structure d’un projet PlatformIO est organisée de manière professionnelle:

1.2 - Le fichier main.cpp

Fichier main.cpp

1.3 - Remplacer le code source de main.cpp par:

#include <Arduino.h>

void setup() {
  Serial.begin(9600);
  Serial.println("Bonjour le Monde!\n");
}

void loop() {
  
  }

Explication du code:

💡Note: Contrairement à l’IDE Arduino qui utilise des fichiers .ino, PlatformIO utilise des fichiers .cpp standard C++. Il faut donc inclure explicitement la librairie Arduino avec #include <Arduino.h>.

2 - Compiler le projet:

Compiler projet

ou -> CTRL+ALT+B

Action compilation

La compilation vérifie le code sans le téléverser sur la carte. C’est utile pour détecter rapidement les erreurs de syntaxe.

Avantages de la compilation PlatformIO:

3 - Téléverser l’application vers le micro-contrôleur

ou -> CTRL+ALT+U

Téléversement

Action téléversement 1

Action téléversement 2

Le téléversement (upload) compile automatiquement le projet si nécessaire, puis transfert le programme vers la carte Arduino.

4 - Afficher le moniteur série (Pour les traces du programme)

Moniteur série

Action moniteur série

ou -> CTRL+ALT+S

Le moniteur série de PlatformIO offre plusieurs avantages:

5 - Hello World avec une DEL (LED)

5.1 – Exemple avec documentation et fichier de logs

// -----------------------------------------------
// Projet: Introduction à Arduino
// Auteur: Alain Boudreault
// Date: 2026.01.25
// -----------------------------------------------
// Ajouter dans platformio.ini
// monitor_filters =
//  default   ; Retire les caractères de contrôle
//  time      ; Horodatage des lignes
//  log2file  ; Log les Serial.print dans le fichier “device-monitor-date-heure*.log” situé dans le dossier 'logs' du projet.

#include <Arduino.h>

void setup() {
  Serial.begin(9600)
  pinMode(13, 1); // OUTPUT
}

void loop() {
  static int i = 0;
  Serial.print("\nItération numéro: " + String(i++));  
  digitalWrite(13, 1); // ON
  delay(500);
  digitalWrite(13, 0); // OFF
  delay(500);
}

👉 Tester l’application et consulter le fichier ‘log’

Explication du code:

5.2 – Utilisation de MACROs

#include <Arduino.h>

#define DEL_ROUGE 13
#define SORTIE 1
#define ALLUMER 1
#define ETEINDRE 0
#define DELAI 500

void setup() {
  pinMode(DEL_ROUGE, SORTIE);
}

void loop() {
  digitalWrite(DEL_ROUGE, ALLUMER);
  delay(DELAI);
  digitalWrite(DEL_ROUGE, ETEINDRE);
  delay(DELAI);
}

👉 Tester l’application

Avantages des macros:

Bonnes pratiques:

6 – Utilisation d’un fichier d’entête (.h)

// Fichier include/main.h 
// Dans main.cpp, ajouter : #include "main.h"
#define DEL_ROUGE 13
#define SORTIE 1
#define ALLUMER 1
#define ETEINDRE 0
#define DELAI 500

Structure recommandée du fichier include/main.h:

#ifndef MAIN_H
#define MAIN_H

// Définitions des broches
#define DEL_ROUGE 13

// Modes des broches
#define SORTIE OUTPUT
#define ENTREE INPUT

// États logiques
#define ALLUMER HIGH
#define ETEINDRE LOW

// Temporisations
#define DELAI 500

#endif // MAIN_H

Et dans main.cpp:

#include <Arduino.h>
#include "main.h"

void setup() {
  pinMode(DEL_ROUGE, SORTIE);
}

void loop() {
  digitalWrite(DEL_ROUGE, ALLUMER);
  delay(DELAI);
  digitalWrite(DEL_ROUGE, ETEINDRE);
  delay(DELAI);
}

Avantages de cette organisation:

Structure professionnelle complète:

mon_projet/
├── platformio.ini          # Configuration du projet
├── src/
│   └── main.cpp           # Code principal
├── include/
│   ├── main.h             # Constantes et macros
│   └── fonctions.h        # Déclarations de fonctions
├── lib/
│   └── MaLibrairie/       # Librairies personnalisées
└── test/
    └── test_main.cpp      # Tests unitaires

7 - Configuration avancée dans platformio.ini

Le fichier platformio.ini permet de configurer finement votre projet:

[env:uno]
platform = atmelavr
board = uno
framework = arduino

; Configuration du port série
monitor_speed = 9600
monitor_filters = colorize

; Librairies du projet
lib_deps = 
    mikem/Streaming @ ^1.0.0
    adafruit/DHT sensor library @ ^1.4.4

; Options de compilation
build_flags = 
    -DDEBUG=1
    -DVERSION="1.0.0"

; Téléversement
upload_speed = 115200

Explications:

8 - Raccourcis clavier utiles

Action Raccourci
Compiler Ctrl + Alt + B
Téléverser Ctrl + Alt + U
Moniteur série Ctrl + Alt + S
Nettoyer Ctrl + Alt + C
Recherche des commandes PIO Ctrl + Shift + P → “PlatformIO”

9 - Conseils pour bien débuter

  1. Toujours inclure <Arduino.h>: C’est obligatoire dans les fichiers .cpp (contrairement aux .ino)

  2. Organiser son code: Utiliser les dossiers src/, include/, lib/ selon leur fonction

  3. Versionner avec Git: PlatformIO s’intègre parfaitement avec Git

  4. Lire les messages de compilation: Ils contiennent des informations précieuses sur l’utilisation mémoire

  5. Utiliser les constantes (MACROs) Arduino: OUTPUT, INPUT, HIGH, LOW préférer aux valeurs numériques

  6. Commenter son code: Documenter les sections importantes et les choix techniques

  7. Tester régulièrement: Compiler et téléverser fréquemment pour détecter les erreurs rapidement

  8. Explorer les exemples: PlatformIO fournit de nombreux exemples de code

Conclusion

PlatformIO représente une solution efficace pour le développement Arduino et embarqué en général. En combinant la simplicité d’Arduino avec la puissance d’un IDE professionnel, avec lequel vous êtes déjà familier (VSCode), il permet aux développeurs de créer des projets plus robustes, maintenables et évolutifs (git).

Crédits

Document rédigé par Alain Boudreault © 2021-2026

Version 2026.01.25.01

Contenu par VE2CUY