Commandes Arduino : liste en 36 fiches, C++ et MicroPython

La façon la plus sûre d'apprendre les commandes Arduino n'est pas de mémoriser une longue liste, mais de les parcourir dans l'ordre, chacune avec un petit exemple et un vrai projet. C'est le rôle du Guide du code, dans la section Leçons de l'onglet Apprendre de l'application BlueGrays : 18 fiches dans le parcours Arduino C++, de pinMode à tone, et 18 fiches dans le parcours MicroPython, de import à I2C, soit 36 fiches. Chaque fiche suit le même plan : À quoi ça sert ?, Pourquoi ?, Syntaxe, Exemple (avec les onglets Blocs, Arduino et MicroPython), Erreur fréquente, Astuce, Voir dans les projets et un Mini-test de deux questions. L'ordre est fixé lui aussi : d'abord les broches (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), puis le temps (delay, millis), ensuite variables, conditions, boucles et fonctions, et pour finir Serial, map, random et tone. Si tu utilises une Raspberry Pi Pico, tu apprends les mêmes notions dans le parcours MicroPython avec Pin, Pin.value, time.sleep, ADC.read_u16 et PWM.

Cet article est une carte du guide. Tu verras d'abord ce que contient une fiche, puis les 18 fiches de chaque parcours dans leur ordre réel dans l'application, avec l'équivalent dans l'autre langage. Viennent ensuite trois courts exemples qui mettent côte à côte la version C++ et la version MicroPython d'un même programme, le fonctionnement du mini-test et du suivi de progression, un ordre d'apprentissage sur 4 semaines, une routine quotidienne de 20 minutes et les 8 erreurs les plus fréquentes avec ces commandes. Si tu cherches une explication détaillée de chaque commande, l'article commandes Arduino : syntaxe et exemples consacre une section à chacune ; celui-ci explique dans quel ordre les apprendre et comment t'entraîner.

Où se trouve le Guide du code et comment fonctionne-t-il ?

Tu ouvres le guide depuis l'onglet Apprendre, en bas de l'écran : dans la section Leçons, en haut, touche la tuile Guide du code. À l'ouverture, tu vois deux onglets en haut : Arduino C++ et MicroPython ; l'application retient le dernier parcours ouvert. Juste en dessous se trouvent le compteur Ce que tu as appris et la ligne Fiche suivante, pour ne jamais chercher où tu t'es arrêté. Les fiches sont regroupées par thème : Broches, Temps, Variables, Conditions, Boucles, Fonctions, Port série, Maths et Son ; le parcours MicroPython ajoute Structure de base et Gestion des erreurs. Le Guide du code est gratuit : pas besoin de Premium pour lire les fiches, voir les exemples ou faire les mini-tests. Les fiches existent en 10 langues, tu lis donc les explications dans la langue de ton application.

Que contient une fiche ?

Toutes les fiches ont la même structure, donc dès la troisième tu sais où regarder. Le tableau présente les sections à partir de la 7e fiche du parcours Arduino, millis ; la colonne de droite résume ce que dit la fiche. L'ordre des sections est déjà un ordre d'apprentissage : d'abord tu découvres en une phrase ce que fait la commande, puis tu comprends à quoi elle sert grâce à une comparaison de la vie courante, tu vois comment elle s'écrit, tu lis un exemple qui fonctionne, tu découvres le piège le plus courant et tu te testes avec deux questions.

La section Exemple s'ouvre sur le parcours de la fiche : sur une fiche Arduino, l'onglet Arduino vient en premier, sur une fiche MicroPython, l'onglet MicroPython. Mais l'autre onglet est toujours là, et c'est ce qui transforme le guide en dictionnaire. Sur la fiche Broche en sortie : Pin(15, Pin.OUT) du parcours MicroPython, par exemple, l'onglet Arduino contient un code qui fait la même chose avec pinMode et digitalWrite, et les commentaires indiquent quelle ligne correspond à quoi (comme la ligne qui remplace led.toggle()). Presque toutes les fiches ont aussi un troisième onglet, Blocs, qui montre le programme d'exemple sous forme de blocs. Si tu passes d'Arduino à la Pico, la méthode la plus rapide est la suivante : ouvre une fiche que tu connais, change d'onglet et fais correspondre les deux programmes ligne par ligne.

Parcours Arduino C++ : 18 fiches et leurs équivalents MicroPython

Le tableau reprend l'ordre réel du parcours Arduino dans l'application ; la dernière colonne montre comment faire la même chose en MicroPython sur une Raspberry Pi Pico. Les numéros de broches correspondent aux exemples des fiches : pour une LED, 13 ou 9 sur l'Uno et GP15 sur la Pico ; pour un bouton, 2 sur l'Uno et GP14 sur la Pico ; pour la lecture analogique, A0 sur l'Uno et GP26 sur la Pico. Les cinq premières fiches portent sur les broches, la 6 et la 7 sur le temps, de la 8 à la 14 sur les bases de la programmation, et les quatre dernières sur le port série, la mise à l'échelle, les nombres aléatoires et le son. L'ordre est voulu : tu apprends d'abord comment la carte agit sur le monde extérieur, puis tu pilotes ces actions avec des variables, des conditions et des boucles.

Parcours MicroPython : 18 fiches et leurs équivalents Arduino

Le parcours MicroPython a été pensé pour la Raspberry Pi Pico ; les exemples des fiches sont de courts programmes que tu peux exécuter sur une Pico, par exemple avec Thonny. L'ordre diffère un peu du parcours Arduino, car en Python il faut d'abord s'habituer aux règles du langage : ajouter des modules avec import, afficher avec print, et la règle de l'indentation et des deux-points. L'onglet Arduino de chaque fiche MicroPython contient aussi la version C++ du même programme ; si tu connais déjà Arduino, tu peux donc lire le tableau de droite à gauche. Si c'est ta première Pico, l'article qu'est-ce que la Raspberry Pi Pico est une bonne préparation pour l'installation et les broches.

Le même programme dans deux langages : 3 exemples côte à côte

Le premier exemple est le « hello world » de tout langage : faire clignoter la LED de la carte toutes les demi-secondes. Sur l'Uno, la LED intégrée est reliée à la broche 13 : aucun circuit à monter. Sur la Pico, c'est un peu différent : sur la Pico classique, la LED intégrée est sur GP25, mais sur la Pico W elle est reliée à la puce sans fil et Pin(25) ne l'allume pas. C'est pourquoi il est plus sûr d'écrire Pin("LED", Pin.OUT) en MicroPython ; dans les versions actuelles de MicroPython, ce nom trouve la LED intégrée sur la Pico comme sur la Pico W. Si le firmware de ta carte ne reconnaît pas le nom "LED", installe un MicroPython récent sur la Pico. Le projet gratuit Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W) explique justement cette différence.

1// Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the built-in LED
2void setup() {
3  pinMode(13, OUTPUT);     // Uno'da dahili LED 13. pinde / built-in LED is on pin 13 on the Uno
4}
5
6void loop() {
7  digitalWrite(13, HIGH);  // LED yanar / LED on
8  delay(500);              // 500 ms bekle / wait 500 ms
9  digitalWrite(13, LOW);   // LED söner / LED off
10  delay(500);              // 500 ms bekle / wait 500 ms
11}

1# Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)  # Pico ve Pico W'de dahili LED / onboard LED on Pico and Pico W
6# Pin(25, Pin.OUT) yalnız düz Pico'da çalışır / Pin(25, Pin.OUT) works only on the plain Pico
7
8while True:                # Arduino'daki loop() gibi / like loop() in Arduino
9    led.on()               # LED yanar / LED on
10    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms
11    led.off()              # LED söner / LED off
12    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms

Le deuxième exemple ajoute une entrée : la LED reste allumée tant que le bouton est enfoncé. Le bouton se branche entre la broche 2 et GND sur l'Uno, et entre GP14 et GND sur la Pico. Sur l'Uno, on reprend la LED intégrée de la broche 13 ; sur la Pico, branche une LED externe sur GP15 avec une résistance de 220 Ω (l'outil Résistance de LED calcule la valeur pour ta propre LED). Dans les deux langages, on active la résistance de tirage interne : INPUT_PULLUP sur Arduino, Pin.PULL_UP en MicroPython. Avec ce câblage, la logique est inversée : un appui relie la broche à GND, l'Arduino lit LOW et la Pico lit 0. La pause de 20 ms à la fin ne règle pas complètement les rebonds mécaniques du bouton, mais elle réduit les clignotements très brefs. Les détails du câblage sont dans l'article brancher un bouton sur Arduino.

1// Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2const int BUTTON_PIN = 2;  // buton: 2. pin ile GND arasında / button between pin 2 and GND
3const int LED_PIN = 13;    // dahili LED / built-in LED
4
5void setup() {
6  pinMode(BUTTON_PIN, INPUT_PULLUP);  // iç pull-up direnci açık / internal pull-up on
7  pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11  if (digitalRead(BUTTON_PIN) == LOW) {  // basılıyken LOW okunur / reads LOW while pressed
12    digitalWrite(LED_PIN, HIGH);
13  } else {
14    digitalWrite(LED_PIN, LOW);
15  }
16  delay(20);  // kısa bekleme / short pause
17}

1# Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2from machine import Pin
3import time
4
5button = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arasında / button between GP14 and GND
6led = Pin(15, Pin.OUT)                 # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7
8while True:
9    if button.value() == 0:            # basılıyken 0 okunur / reads 0 while pressed
10        led.value(1)
11    else:
12        led.value(0)
13    time.sleep_ms(20)                  # kısa bekleme / short pause

Le troisième exemple montre la différence la plus importante entre les deux langages : les plages de nombres. La patte du milieu du potentiomètre va sur A0 sur l'Uno et sur GP26 sur la Pico ; les pattes extérieures vont sur 5V et GND sur l'Uno, et sur 3V3 (OUT) et GND sur la Pico. La LED se branche sur la broche 9 (marquée ~) de l'Uno et sur GP15 de la Pico, chaque fois avec une résistance de 220 Ω. Sur Arduino, analogRead renvoie 0–1023 mais analogWrite attend 0–255 : d'où le map(raw, 0, 1023, 0, 255) entre les deux. Sur la Pico, read_u16 et duty_u16 utilisent tous deux 0–65535, tu peux donc passer la mesure directement au PWM. Le fonctionnement du PWM est expliqué dans l'article qu'est-ce que le PWM, et l'affichage des valeurs en direct dans le guide du moniteur série.

1// Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2const int POT_PIN = A0;  // potansiyometrenin orta ucu / potentiometer wiper
3const int LED_PIN = 9;   // ~ işaretli PWM pini / PWM pin marked with ~
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(POT_PIN);               // 0-1023
12  int brightness = map(raw, 0, 1023, 0, 255);  // 0-255 aralığına ölçekle / scale to 0-255
13  analogWrite(LED_PIN, brightness);
14  Serial.println(raw);                         // Seri Monitör'de izle / watch in the Serial Monitor
15  delay(50);
16}

1# Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26)            # GP26 = ADC0, orta uç / wiper on GP26 (ADC0)
6led = PWM(Pin(15))       # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7led.freq(1000)           # saniyede 1000 aç-kapa / 1000 cycles per second
8
9while True:
10    raw = pot.read_u16()     # 0-65535
11    led.duty_u16(raw)        # aynı aralık, ölçekleme gerekmez / same range, no scaling needed
12    print(raw)               # Thonny kabuğunda izle / watch in the Thonny shell
13    time.sleep_ms(50)

Mini-test, « Compris » et ta progression dans Mon niveau

• Mini-test : Chaque fiche se termine par deux questions, et le titre indique Mini-test · 1 / 2. Quand tu touches une réponse, tu obtiens tout de suite Exact. ou Pas tout à fait. avec une courte explication ; tu continues avec Question suivante.
• Score : Une fois les deux questions faites, tu vois un score comme 2 / 2 bonnes réponses. La fiche ne peut pas être terminée sans le test ; à la place du bouton s'affiche Fais le mini-test pour terminer la fiche.
• Compris : Le test terminé, le bouton Compris, fiche suivante apparaît (sur la dernière fiche d'un parcours, seulement Compris). En le touchant, la fiche est enregistrée comme apprise sur ton compte, une petite célébration affiche ta progression, par exemple Super ! 5 / 18 fiches, et la fiche suivante s'ouvre.
• Badge et compteur : Les fiches apprises portent la mention Apprise dans la liste, et le compteur Ce que tu as appris en haut du guide augmente. Quand tu as terminé toutes les fiches d'un parcours, le message Tu as appris toutes les fiches de ce parcours s'affiche.
• Mon niveau : Sur l'écran Mon niveau de la section Apprendre, sous le titre Guide du code et la mention Fiches apprises, il y a deux barres séparées : Arduino C++ x/18 et MicroPython x/18. Ces barres ne comptent que les fiches du guide du code.
• Une règle honnête avec toi-même : L'application ne te bloque pas après une mauvaise réponse ; le bouton Compris apparaît dès que le test est fini. Avant de le toucher, assure-toi donc de pouvoir expliquer à voix haute pourquoi les deux réponses sont correctes ; sinon, reviens à la section Exemple et relis le code ligne par ligne.

Voir dans les projets : retrouver la commande dans du vrai code

La dernière étape pour apprendre une commande, c'est de la reconnaître dans un projet qui fonctionne et qu'une autre personne a écrit. Dans la section Voir dans les projets, la fiche présente quelques projets choisis et, en dessous, une phrase qui indique dans combien de projets la commande apparaît ; le lien Tous ouvre la liste complète. Elle est triée du plus facile au plus difficile et se filtre avec Tous, Gratuit et Premium. millis, par exemple, apparaît dans le code de plus de 50 projets : la liste commence par le projet gratuit ESP32 Contrôle de LED avec bouton (Toggle), continue avec des projets Pico pour débutants comme Piano à boutons avec Raspberry Pi Pico (5 boutons + buzzer + enregistreur) et Radar de recul avec Raspberry Pi Pico (HC-SR04 + 3 LED + buzzer), puis monte vers des projets de niveau intermédiaire comme Feu de signalisation Raspberry Pi Pico avec sélecteur à 4 modes (machine à états, GP11-13 + GP4), qui associent un bouton et une temporisation. Notre conseil : ouvre un projet gratuit de la liste, cherche la commande dans le code, change une valeur et prédis le résultat avant de tester. Pour voir ce que fait chaque ligne, l'onglet Comprendre le code du projet est l'étape suivante naturelle.

Ordre d'apprentissage conseillé : un plan sur 4 semaines

Supposons que tu peux consacrer environ 20 minutes par jour, 5 jours par semaine. Pour terminer un parcours en 4 semaines, une fiche suffit la plupart des jours ; les autres jours, tu révises et tu travailles sur un projet au lieu d'une nouvelle fiche. Si tu as un Arduino, suis seulement la colonne Arduino ; si tu as une Pico, la colonne MicroPython. Si tu as les deux cartes, termine d'abord le parcours Arduino et passe à MicroPython le deuxième mois ; les notions sont les mêmes, le second parcours va donc beaucoup plus vite. Tous les projets du tableau sont gratuits sur BlueGrays. Pour un plan plus large, la feuille de route sur 30 jours de l'article application pour apprendre Arduino se combine bien avec ce tableau ; si tu enseignes avec la Pico, le cours Raspberry Pi Pico répartit les fiches MicroPython sur 6 semaines de cours.

Une routine quotidienne de 20 minutes

1. 3 minutes, échauffement : Réponds aux questions du jour dans la section Apprendre ou refais le mini-test d'hier. L'objectif est de vérifier que tu te souviens encore aujourd'hui de la commande d'hier.
2. 5 minutes, nouvelle fiche : Lis les sections À quoi ça sert ?, Pourquoi ? et Syntaxe. Recopie la syntaxe à la main sur une feuille ; en l'écrivant, tu laisses beaucoup moins passer les parenthèses et les points-virgules.
3. 3 minutes, exemple : Explique-toi l'exemple ligne par ligne, puis change d'onglet. Sur une fiche Arduino, regarde l'onglet MicroPython, sur une fiche MicroPython l'onglet Arduino, et fais correspondre les lignes qui font la même chose dans les deux programmes.
4. 2 minutes, mini-test : Réponds aux deux questions et lis l'explication de celle que tu as ratée. Jette à ce moment-là un nouveau coup d'œil aux encadrés Erreur fréquente et Astuce.
5. 6 minutes, projet : Ouvre un projet gratuit et facile depuis la liste Voir dans les projets, trouve la commande dans le code et change une seule valeur : une attente, un numéro de broche ou un seuil. Si ton circuit est prêt, téléverse le code sur la carte ; sinon, prédis le résultat et vérifie-le avec Comprendre le code.
6. 1 minute, note : Écris une ligne dans ton cahier : le nom de la commande, son sens en une phrase et son équivalent dans l'autre langage. Au bout de quatre semaines, cette page devient ton propre dictionnaire de commandes.

8 erreurs fréquentes avec ces commandes

L'onglet Blocs : comprendre une commande en la voyant

L'onglet Blocs te montre ce que fait une commande sans écrire de code, surtout sur les premières fiches d'un parcours. Dans l'image ci-dessus, pinMode devient le bloc « régler la broche 9 en SORTIE », digitalWrite devient « écrire HAUT sur la broche 9 » et delay « attendre 100 ms » ; sur la fiche pinMode, une note sous la vue en blocs rappelle aussi les options du menu déroulant : SORTIE, ENTRÉE et ENTRÉE (PULLUP). Les blocs s'affichent dans la langue de l'application et servent à lire : dans l'application, tu ne fais pas glisser de blocs pour écrire un programme, et la carte reçoit toujours le vrai code. La méthode conseillée : prédis d'abord dans l'onglet Blocs ce que fera le programme, puis passe à l'onglet Arduino et retrouve à quelle ligne correspond chaque bloc. Dans les projets qui ont une vue en blocs, l'interrupteur Voir en blocs de la page du projet te permet de faire la même correspondance sur un projet entier ; les bases sont dans l'article qu'est-ce que la programmation par blocs.

En bref, pas besoin d'une longue liste pour apprendre les commandes Arduino : il suffit du bon ordre, d'un petit exemple qui fonctionne pour chaque commande, d'une vérification en deux questions et d'un vrai projet qui utilise la commande. Si tu commences aujourd'hui par la fiche pinMode, dans quatre semaines tu auras terminé les 18 fiches et vu chaque commande de tes propres yeux dans au moins un projet ; quand tu passeras à la Pico, tu parcourras les mêmes notions dans le parcours MicroPython beaucoup plus vite. Si tu veux essayer les fiches et les projets qu'elles contiennent, installe BlueGrays sur ton téléphone et ouvre la première fiche dans la section Apprendre.