Passer des blocs au code Arduino : tableau C++ et MicroPython

Le moyen le plus rapide de passer des blocs au code Arduino est de garder près de toi un tableau d’une page qui montre en quelle ligne de vrai code chaque bloc se transforme. La réponse courte : les blocs ne sont pas un nouveau langage, ce sont la forme visuelle de lignes Arduino C++. Le bloc « régler la broche 13 en SORTIE » est la ligne pinMode(13, OUTPUT);, le bloc « attendre 1000 ms » est delay(1000); et le bloc « si … faire » est une instruction if. Le tableau ci-dessous place les vrais libellés des blocs de l’appli BlueGrays à côté de leur code Arduino C++ et de leur code MicroPython sur le Raspberry Pi Pico.

Cette page n’est pas un cours, c’est une fiche de référence. Tu peux imprimer le tableau, le garder près de ton poste et vérifier quelle ligne correspond à quel bloc pendant que tu regardes un projet. Après le tableau, tu trouveras les erreurs les plus fréquentes au moment du passage, une méthode en quatre étapes pour laisser les blocs derrière toi et le même programme écrit en blocs, en C++ et en MicroPython. L’exemple compile dans l’Arduino IDE et tourne sur le Pico avec Thonny.

Avant de lire le tableau : quatre différences entre les trois

Blocs, C++ et MicroPython expriment la même idée, mais les règles d’écriture diffèrent. C’est sur ces quatre différences que tu trébucheras le plus. La première est la structure : un programme Arduino C++ a deux parties appelées setup() et loop(), qui apparaissent dans les blocs comme « configuration (une fois) » et « répéter indéfiniment ». MicroPython n’a pas de setup séparé ; le fichier s’exécute une fois de haut en bas et la partie qui se répète va dans une boucle while True:. La deuxième, ce sont les types : en C++ chaque variable a un type écrit (int, float, bool), dans les blocs c’est l’option « déclarer entier (int) », et en Python on n’écrit aucun type.

La troisième différence concerne les plages de nombres. Sur l’Arduino Uno une lecture analogique va de 0 à 1023 et le PWM de 0 à 255 ; sur l’ESP32 la lecture analogique monte à 0–4095 ; sur le Pico, MicroPython donne les lectures comme le rapport cyclique PWM dans la plage 0–65535. Tu ne peux donc pas recopier un seuil d’une carte à l’autre tel quel. La quatrième différence est l’unité de temps : delay() attend des millisecondes, time.sleep() des secondes. Une demi-seconde, c’est delay(500) en C++ et time.sleep(0.5) en MicroPython. Garde ces quatre règles en tête et la plupart des lignes du tableau se mettent en place toutes seules.

• Les nombres du tableau sont des exemples : là où le bloc indique 13, ton projet peut utiliser 7, et le nombre de la ligne de code change avec lui.
• Les broches de la colonne MicroPython sont les numéros GP du Pico (GP14, GP15, GP26). Elles n’ont pas à correspondre aux broches de l’Uno ; regarde le schéma.
• Les lignes marquées « Pas de bloc Pico » signifient que ce bloc n’est pas utilisé dans les projets Pico ; le code MicroPython qui fait le même travail est quand même donné.
• L’ESP32 se programme lui aussi en Arduino C++ ; la colonne C++ vaut aussi pour lui, seuls la plage analogique et certains numéros de broches changent.

Tableau de correspondance : blocs, Arduino C++ et MicroPython

Le tableau est divisé en 12 groupes : structure du programme, broches, temps, condition, boucle, variables, maths, port série, analogique et PWM, son, servo et capteur. Le texte de la colonne Bloc est le libellé inscrit sur les blocs dans l’appli ; « … » et « ? » marquent l’emplacement où un autre bloc vient se brancher. Quand une ligne contient plusieurs blocs, ils sont séparés par un point.

Certaines lignes semblent directes au premier coup d’œil mais demandent de l’attention. Dans « compter avec i de 0 à 5 », le 5 est inclus et la boucle tourne 6 fois ; c’est pourquoi on écrit <= au lieu de < en C++, et Python a besoin de range(0, 6), car range exclut le nombre final. Le bloc de division est aussi un piège : quand tu divises deux entiers, C++ jette la partie décimale et 7 / 2 donne 3, alors que Python donne 3.5. Pour une division entière comme en C++, Python utilise //. La fonction map() derrière le bloc « convertir x » n’est pas intégrée à MicroPython ; dans l’exemple ci-dessous, une fonction arduino_map() de deux lignes fait le même calcul.

Comment les blocs imbriqués deviennent-ils du code ?

Connaître les blocs un par un ne suffit pas ; la vraie compétence est de transformer des blocs imbriqués en une seule ligne. Pour cela, distingue deux formes. Les blocs empilés les uns sous les autres, avec une encoche sur le bord, sont des instructions, et chacun devient une ligne de code. Les blocs ovales ou pointus qui se branchent dans l’emplacement d’un autre bloc sont des valeurs ; dans le code, ils se placent entre parenthèses, à droite d’un signe égal ou dans une condition. Les lignes ci-dessous viennent du projet gratuit Réglage de la fréquence avec buzzer : quatre boutons allument et éteignent le son, augmentent ou baissent sa fréquence, qui reste entre 50 et 5000 Hz.

Prends une habitude en lisant ce tableau : traduis d’abord le bloc le plus intérieur, puis avance vers l’extérieur. Dans « définir frequency à (contraindre frequency entre 50 et 5000) », la partie la plus intérieure est constrain(frequency, 50, 5000), et le bloc définir extérieur l’enveloppe en frequency = …. Un bloc de valeur ne peut pas être une ligne à lui seul ; si tu le laisses avec un point-virgule, le compilateur ne protestera peut-être pas, mais le résultat n’est stocké nulle part.

Erreurs fréquentes en passant des blocs au code

L’éditeur de blocs ne te laisse pas faire la plupart de ces erreurs ; la forme des pièces les empêche de s’emboîter au mauvais endroit. Dans le code, cette protection disparaît, si bien que presque tout le monde rencontre les erreurs ci-dessous dans les premières semaines. Les messages d’erreur sont en anglais, mais les modèles sont peu nombreux et, après les avoir vus deux ou trois fois, tu les reconnaîtras.

Laisser les blocs derrière soi : méthode en 4 étapes

Vouloir tout changer d’un coup est épuisant. Les quatre étapes ci-dessous vont de la lecture à l’écriture par petits pas. Un ou deux projets par étape suffisent ; tu es prêt pour la suivante quand tu réussis l’étape en cours sans regarder le tableau.

1. Lire côte à côte. Ouvre en même temps les blocs et le code d’un projet et associe du doigt chaque bloc à sa ligne de code. Garde le tableau à côté de toi pendant cette étape. Objectif : pouvoir relier chaque ligne de code à un bloc.
2. Masquer les blocs et deviner. Regarde d’abord les blocs, puis désactive l’affichage en blocs et écris sur papier le C++ de ces blocs sans regarder le code. Compare ensuite avec le vrai code. Essaie aussi dans l’autre sens : lis le code et devine les blocs.
3. Changer une valeur dans le code. Récupère le code sur ton ordinateur et modifie un seul nombre : passe l’attente de 100 à 500 ou le seuil de 400 à 600. Téléverse-le et vois la différence de tes propres yeux. En cas d’erreur de compilation, reviens au tableau des erreurs ci-dessus.
4. Écrire une nouvelle ligne. Ajoute une ligne qui n’existe pas dans les blocs : un Serial.println() qui affiche la valeur dans le moniteur série, une deuxième LED ou un if qui fonctionne avec un bouton. Tu ne traduis plus des blocs, tu écris directement du code.

Chaque étape a sa leçon dans la série. Pour la première, le tableau bloc-ligne de l’article allumer une LED avec des blocs est un bon point de départ. Pour les conditions et les boucles des étapes deux et trois, consulte le bloc si et boucles et variables. Si tu passes à MicroPython avec le Pico, des blocs à MicroPython explique aussi l’installation de Thonny. Pour étaler le passage sur plusieurs semaines de cours, le programme de robotique sur 8 semaines propose un ordre tout prêt.

Ouvrir blocs et code côte à côte dans l’appli BlueGrays

Tu utiliseras surtout ce tableau en faisant des allers-retours entre les blocs et le code d’un vrai projet. L’appli BlueGrays propose un affichage en blocs pour plus de 100 projets ; dans plus de 30 projets gratuits les blocs sont aussi accessibles, et dans les projets Premium les blocs se débloquent avec Premium. Les blocs servent à lire : dans l’appli, on ne modifie pas les blocs et ils ne sont pas téléversés sur la carte. Ce qui part sur la carte, c’est toujours le vrai code ; tu le récupères avec Copier, ou avec Copier le lien pour l’ouvrir sur ton ordinateur, puis tu le colles dans l’Arduino IDE ou, pour le Pico, dans Thonny.

• Voir en blocs : active cet interrupteur à côté du code source sur la page d’un projet et le même programme apparaît sous forme d’image de blocs dans la langue de l’appli. Touche l’image pour l’ouvrir en plein écran ; l’activer et le désactiver, c’est exactement l’entraînement des étapes un et deux.
• Comprendre les blocs : avec l’affichage en blocs actif, l’onglet « Comprendre le code » prend ce nom. Le programme est découpé en étapes, chacune avec la partie concernée et une explication. La tâche « À toi de jouer » à la fin est un exercice tout prêt pour l’étape quatre.
• Guide du code : chacune des 36 cartes de la section Apprendre (18 Arduino C++, 18 MicroPython) montre son exemple de trois façons avec les onglets Blocs, Arduino et MicroPython. Pour voir une ligne du tableau plus en détail, ouvre la carte correspondante.
• Projets en blocs : cette option de Filtrer, dans Découvrir > Projets, n’affiche que les projets qui ont un affichage en blocs, ce qui facilite le choix d’un projet pour le passage.

Nous avons expliqué le fonctionnement du guide du code dans l’article sur le guide du code, et les sections « Comprendre le code » et « À toi de jouer » dans le guide Comprendre le code. Pour chaque commande expliquée une à une, la liste des commandes Arduino va bien avec ce tableau.

Un programme sous trois formes : une veilleuse qui varie avec la lumière

Pour voir le tableau en action, construisons un petit programme. Une LDR mesure la lumière ; tant que la pièce est éclairée, la LED reste éteinte, et plus il fait sombre, plus la LED s’allume progressivement. Le programme utilise des blocs de variable, de lecture analogique, de condition, de conversion, de PWM, de port série et d’attente : plus de la moitié du tableau apparaît dans un seul exemple. L’idée s’appuie sur le projet gratuit Veilleuse avec LDR ; là-bas la LED est seulement allumée ou éteinte, ici le PWM la fait varier. Pour le câblage de la LDR, tu peux aussi regarder le schéma du projet Mesurer l'intensité lumineuse avec une LDR.

D’abord la version en blocs. Avec les libellés de l’appli, le programme se compose des blocs suivants ; chaque élément correspond à une ou plusieurs lignes du code C++ qui suit :

1. variables globales (en haut) : déclarer entier (int) lightValue = 0 et déclarer entier (int) brightness = 0
2. configuration (une fois) : démarrer le port série à 9600 bauds, puis régler la broche 9 en SORTIE
3. répéter indéfiniment : définir lightValue à (lecture analogique A0)
4. si (lightValue < 400) faire : définir brightness à (convertir lightValue : 0 – 400 → 255 – 0) ; sinon : définir brightness à 0
5. écrire PWM brightness sur la broche 9
6. écrire sur le port série « Light: » sans retour, écrire sur le port série lightValue sans retour, écrire sur le port série « PWM: » sans retour, écrire sur le port série brightness retour à la ligne
7. attendre 200 ms

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

En comparant les deux programmes ligne par ligne, toutes les différences du tableau apparaissent. Le setup() du C++ devient en Python les lignes avant while True, et Serial.begin() disparaît. analogRead(A0) devient ADC(26).read_u16() et la plage passe de 0–1023 à 0–65535, d’où un seuil de 25600 au lieu de 400. Au lieu d’analogWrite(9, …), on crée d’abord un objet PWM et la luminosité est réglée avec duty_u16() entre 0 et 65535. Comme map() n’est pas intégré, on écrit une fonction arduino_map() ; la division entière // qu’elle contient correspond à la division entière du C++. Un seul print() remplace quatre Serial.print(), et delay(200) devient time.sleep(0.2).

Passer des blocs au code Arduino C++, c’est moins apprendre par cœur quelque chose de nouveau que reconnaître la forme écrite de blocs que tu connais déjà. Garde ce tableau près de toi, lis d’abord côte à côte dans chaque projet, puis masque les blocs et écris toi-même. Si tu veux voir ces lignes dans de vrais projets, ouvre dans l’appli BlueGrays un projet avec affichage en blocs et passe d’une forme à l’autre du même programme avec Voir en blocs.