Raspberry Pi Pico programmation par blocs : capteurs et MicroPython

La programmation par blocs du Raspberry Pi Pico en MicroPython devient bien plus simple quand tu sais déjà lire un capteur avec des blocs. Lire un capteur avec des blocs, c'est obtenir une valeur sans taper de code : le bloc « lecture analogique A0 » récupère le niveau de lumière d'une LDR, et le bloc « écrire sur le port série » envoie ce nombre au moniteur série de ton ordinateur. Dans cet article, tu vas d'abord lire des capteurs avec des blocs sur Arduino grâce aux projets LDR et HC-SR04, en comparant chaque bloc avec sa ligne analogRead(), Serial.begin(), Serial.println() ou pulseIn(). Ensuite, tu passeras de la programmation par blocs à MicroPython sur le Raspberry Pi Pico et tu verras ce qui change quand les mêmes blocs deviennent du code Python.

Jusqu'ici, tous les programmes de la série agissaient vers l'extérieur : nous avons allumé des LED, lu un bouton et construit un compteur avec une boucle. Lire un capteur fonctionne dans l'autre sens : la carte mesure son environnement et toi, tu vois le nombre. C'est pourquoi le port série entre en jeu ici, car le moyen le plus simple de comprendre ce que mesure un capteur est de suivre sa valeur à l'écran. Dans la seconde moitié, les blocs des projets Raspberry Pi Pico correspondent à du MicroPython au lieu du C++. Tous les projets utilisés sont gratuits dans BlueGrays, et le code cité est exactement celui du projet.

Que veut dire lire un capteur : entrées numériques et analogiques

Un bouton ne signale que deux états : appuyé ou non. Tu le lis avec le bloc de lecture numérique d'une broche (digitalRead) et le résultat vaut 0 ou 1. Des composants comme une LDR, un potentiomètre ou un capteur d'humidité du sol donnent au contraire toutes les valeurs intermédiaires : la tension sur la broche varie en continu entre 0 et 5 V. Le circuit qui transforme cette tension en nombre s'appelle l'ADC (convertisseur analogique-numérique, ou CAN). L'ADC de l'Arduino Uno est sur 10 bits : il découpe la tension en 1024 pas et renvoie un nombre de 0 à 1023, chaque pas valant environ 4,9 mV. L'ESP32 et le Pico ont des ADC 12 bits qui fonctionnent en 3,3 V. Cette différence entre cartes est l'une des sources de confusion les plus fréquentes quand on passe des blocs au code ; tous les détails sont dans l'article ADC et conversion analogique-numérique.

Lire une LDR avec des blocs sur Arduino

Notre premier exemple est le projet Mesurer l'intensité lumineuse avec une LDR. Une LDR est une résistance dont la valeur baisse quand la lumière augmente ; à elle seule, elle ne produit aucune tension. Pour la mesurer, on la place en série avec une résistance fixe de 10 kΩ pour former un pont diviseur de tension, et on relie le point milieu à A0. Avec le câblage ci-dessous, la LDR est côté 5V : plus il y a de lumière, plus la tension sur A0 et la valeur lue augmentent ; si tu inverses la LDR et la résistance, le sens s'inverse. Tu peux calculer la sortie du pont pour différentes valeurs de LDR avec le calculateur de pont diviseur, et voir combien d'ohms fait une LDR dans le noir et en pleine lumière dans l'article capteur de lumière LDR. Nous utiliserons la colonne Pico du tableau dans l'exemple MicroPython de la fin.

Lis les blocs de haut en bas. Le bloc « déclarer entier (int) value = 0 » dans variables globales (en haut) correspond à la ligne int value; tout en haut du code. La section configuration (une fois) contient un seul bloc, « démarrer le port série à 9600 bauds », c'est-à-dire Serial.begin(9600);. Dans répéter indéfiniment, on trouve d'abord « définir value à lecture analogique A0 », soit la ligne value = analogRead(A0);. Viennent ensuite deux blocs « écrire sur le port série ». Le premier écrit le texte « Value: » avec l'option sans retour et devient Serial.print() ; le second écrit value avec retour à la ligne et devient Serial.println(). Ainsi, chaque mesure s'affiche sur une seule ligne, par exemple « Value: 512 ». Le dernier bloc, « attendre 500 ms », est delay(500);, ce qui donne deux mesures par seconde. Pour convertir la valeur en tension, utilise value × 5,0 / 1023 : 512 correspond à environ 2,5 V. Dans une pièce sombre, la valeur descend à quelques centaines ; avec une lampe torche sur la LDR, elle dépasse 900. Les chiffres exacts dépendent de ta LDR et de la lumière ambiante.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Ouvrir le moniteur série et suivre les valeurs

1. Colle le code dans l'Arduino IDE, choisis la carte et le port, puis clique sur Téléverser.
2. Une fois le téléversement terminé, clique sur l'icône de loupe en haut à droite ou ouvre Outils > Moniteur série (raccourci Ctrl+Maj+M).
3. Règle la vitesse du moniteur série sur la valeur du code : 9600 bauds pour ce projet.
4. Une ligne « Value: … » défile toutes les demi-secondes. Cache la LDR avec ta main et regarde le nombre baisser.
5. Pour voir l'évolution sous forme de courbe, ouvre Outils > Traceur série ; les mêmes données sont tracées dans le temps.
6. Les réglages de fin de ligne et l'envoi de données du moniteur série vers la carte sont expliqués en détail dans l'article moniteur série Arduino.

Distance avec le HC-SR04 : attendre en µs et durée de l'impulsion

Le deuxième projet de capteur est HC-SR04 Mesure de la distance (affichage en série). Il apporte deux nouveaux blocs. Le trio qui commence par « écrire HAUT sur la broche trigPin » demande au capteur d'émettre une salve d'ultrasons : le bloc « attendre 10 µs » du milieu est delayMicroseconds(10); et correspond à une attente mille fois plus courte que « attendre … ms ». Vient ensuite « définir duration à durée de l'impulsion HAUT sur la broche echoPin (µs) », c'est-à-dire la ligne unsigned long duration = pulseIn(echoPin, HIGH);, qui mesure combien de microsecondes la broche Echo reste à l'état HAUT. Le son parcourt environ 0,034 cm/µs dans l'air, et cette durée couvre l'aller-retour. C'est pourquoi « définir totalPath à duration × 0.034 » calcule le trajet complet et « définir distance à totalPath ÷ 2 » la distance simple. Par exemple, une impulsion de 1000 µs représente 34 cm de trajet, donc 17 cm de distance ; comme distance est un int, les décimales sont supprimées. Enfin, le bloc « si distance > minDistance et distance < maxDistance » devient if (distance > minDistance && distance < maxDistance) et n'affiche que les mesures entre 3 et 100 cm. Si le capteur ne reçoit pas d'écho, pulseIn() renvoie 0, et ce test écarte aussi ces faux zéros de l'écran. Dans le code, les broches sont trigPin = 7 et echoPin = 6. La portée et la précision du capteur sont détaillées dans l'article capteur de distance HC-SR04.

La même idée sur l'ESP32 : un ADC 12 bits

La version ESP32 de la même logique LDR est le projet Mesure de l'intensité lumineuse avec le module LDR ESP32. Les blocs correspondent toujours à du C++ et se lisent comme sur Arduino, avec trois différences. D'abord, setup() fixe l'ADC sur 12 bits avec analogReadResolution(12) : analogRead() renvoie donc 0–4095 au lieu de 0–1023, et un seuil écrit pour Arduino comme « sombre en dessous de 500 » n'a pas le même sens sur l'ESP32. Ensuite, le port série tourne à 115200 bauds au lieu de 9600 : règle aussi le moniteur série sur 115200. Enfin, sur la sortie AO du module LDR, la tension et la valeur brute baissent quand la lumière augmente. C'est pourquoi le code utilise les valeurs d'étalonnage RAW_DARK = 4000 et RAW_LIGHT = 100, maintient la mesure dans cette plage avec constrain() et la transforme avec map() en 0 % pour le noir et 100 % pour la lumière. Sur un ESP32 DevKit classique, la LDR va sur le GPIO 34, une broche d'entrée seule reliée à l'ADC1. Comme les broches de l'ADC2 ne peuvent pas être lues quand le Wi-Fi est actif, brancher les capteurs analogiques sur l'ADC1 est une bonne habitude. Les caractéristiques générales de la carte sont dans l'article ESP32, c'est quoi.

Des blocs au MicroPython sur le Raspberry Pi Pico

Dans les projets Pico, les blocs correspondent à du MicroPython au lieu du C++. Les blocs ont un air familier, mais le langage en dessous est différent : pas d'accolades ni de points-virgules, les blocs de code sont délimités par l'indentation, et il n'y a pas de fonctions setup() et loop(). Faisons la transition avec le projet le plus simple, Allumage d'une LED externe sur le Raspberry Pi Pico (GP14 + plaque d'essai). Le circuit est minuscule : GP14 (broche physique 19) va à la patte longue de la LED à travers une résistance de 220 à 330 Ω, et la patte courte va au GND (par exemple la broche physique 18). Le programme allume la LED une demi-seconde, l'éteint une demi-seconde et écrit une ligne dans la console Shell de Thonny à chaque étape. Si tu découvres le Pico, commence par l'article Raspberry Pi Pico, c'est quoi.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

Quatre points ressortent de ce tableau. Premièrement, les lignes from machine import Pin et import time n'ont pas de bloc : en Python, on importe en haut les modules dont on a besoin, et les blocs le supposent pour toi. Deuxièmement, le bloc Arduino « démarrer le port série à 9600 bauds » n'a pas d'équivalent ici : sur le Pico, la sortie de print() passe directement par l'USB vers la console Shell de Thonny, sans vitesse à régler. Troisièmement, l'unité d'attente a changé : sur Arduino, « attendre 500 ms » est delay(500), alors que sur le Pico, « attendre 0.5 secondes » est time.sleep(0.5). Quatrièmement, et c'est le plus important, l'indentation : chaque bloc emboîté dans « répéter indéfiniment » s'écrit dans le code avec quatre espaces de retrait sous la ligne while True:. Si tu supprimes le retrait d'une ligne, elle sort de la boucle ; en Python, les espaces font le travail des accolades du C++. Tu trouveras les autres règles de base dans l'article les bases de MicroPython.

Les mêmes opérations dans trois langages : blocs, C++ et MicroPython

Ton propre exemple : lire une LDR sur le Pico en MicroPython

Transposons maintenant le projet LDR d'Arduino sur le Pico. Le câblage suit la colonne Pico du tableau plus haut : une patte de la LDR sur la broche 3V3(OUT), l'autre à la fois sur GP26 et sur une extrémité de la résistance de 10 kΩ, et l'autre extrémité de la résistance au GND. Le Pico possède trois broches capables de lire des valeurs analogiques : GP26 (ADC0), GP27 (ADC1) et GP28 (ADC2). En MicroPython, tu crées un objet ADC(26) et tu appelles read_u16() ; même si l'ADC du Pico est en 12 bits côté matériel, cette fonction met le résultat à l'échelle 0–65535. Pour obtenir la tension, multiplie la valeur par 3,3 et divise par 65535. Le programme suit le même déroulé que la version Arduino : mesurer, afficher, attendre une demi-seconde. Nous avons ajouté un seuil : quand la pièce s'assombrit, la LED intégrée s'allume. En pensant en blocs, les lignes avant while True forment la section « configuration (une fois) », while True: est « répéter indéfiniment », le if/else est le bloc « si » de la partie 3 de la série, led.on() est « allumer (on) la broche led », time.sleep(0.5) est « attendre 0.5 secondes », et le + str() dans print() est le bloc « créer un texte avec ». La ligne ADC(26).read_u16() fait le travail du bloc Arduino « lecture analogique A0 ». Ajuste THRESHOLD selon les nombres que tu vois dans la console Shell, dans ta propre pièce.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Téléverser sur le Pico avec Thonny et main.py

1. Installe Thonny sur ton ordinateur. Si le Pico n'a pas encore MicroPython, maintiens le bouton BOOTSEL enfoncé en branchant le câble USB ; Thonny propose d'installer MicroPython lors de la première connexion.
2. En bas à droite de Thonny, choisis MicroPython (Raspberry Pi Pico) comme interpréteur. Si l'invite >>> s'affiche dans la console Shell en bas, la connexion est établie.
3. Copie le code du projet depuis BlueGrays et colle-le dans l'éditeur de Thonny.
4. Clique sur le bouton vert Exécuter ou appuie sur F5. Le code tourne sur le Pico et les sorties de print() s'affichent dans la console Shell. Pour l'arrêter, utilise le bouton Stop (Ctrl+F2).
5. Pour que le code fonctionne sans ordinateur, choisis Fichier > Enregistrer sous, sélectionne Raspberry Pi Pico dans la fenêtre et nomme le fichier main.py. Le Pico lance ce fichier automatiquement à chaque mise sous tension : un chargeur USB ou une batterie externe suffit.
6. Si Thonny ne voit pas la carte, vérifie le câble et les pilotes dans l'ordre de l'article Raspberry Pi Pico non reconnu.

D'autres projets Pico en blocs gratuits

• Clignotement LED intégrée Raspberry Pi Pico (GP25) : aucun câblage ; la LED de la carte clignote avec LED_PIN = 25. Le code est presque identique à celui du projet précédent : ouvre-les côte à côte et tu verras que seul le numéro de broche change. Sur le Pico W, la LED intégrée est reliée à la puce Wi-Fi, on utilise donc Pin("LED").
• Raspberry Pi Pico Deux LEDs alternées (GP14 + GP13) : il part d'états opposés avec led1.value(1) et led2.value(0), puis applique toggle() aux deux LED dans la boucle. Comme le code écrit from time import sleep, l'attente apparaît sous la forme sleep(0.5) au lieu de time.sleep(0.5).
• Simulateur de feu de circulation Raspberry Pi Pico (GP11/GP12/GP13) : une fonction all_off() éteint toutes les LED ; le vert reste allumé 4 secondes, l'orange 1,5 et le rouge 3, puis vient une phase de démarrage rouge+orange d'une seconde.
• Raspberry Pi Pico Effet gyrophare police (GP11 + GP12) : cette fois, l'attente se fait en millisecondes avec sleep_ms(WAIT_MS), où WAIT_MS = 300. Voir les fonctions en secondes et en millisecondes dans deux projets différents est le meilleur moyen d'éviter l'erreur la plus fréquente ci-dessous.

Erreurs fréquentes et solutions

Continuer avec les blocs dans l'application BlueGrays

Tous les projets de cet article sont gratuits dans l'application BlueGrays. Active l'interrupteur Voir en blocs dans la partie code d'un projet : le code est remplacé par le même programme en blocs, et un appui sur l'image l'ouvre en plein écran. L'onglet Comprendre les blocs explique le programme étape par étape et n'affiche à chaque étape que les blocs concernés et ce qu'ils font. C'est là que tu peux voir précisément ce que mesure le bloc de durée d'impulsion dans le projet HC-SR04, ou pourquoi la partie configuration d'un projet Pico vient avant while True. Tous les exemples de commandes Arduino et MicroPython du Guide du code existent aussi en blocs. Pour tester tes connaissances, les Questions du jour proposent 5 questions par jour du niveau A1 au niveau C2, un classement hebdomadaire et des badges. N'oublie pas que les blocs ne sont jamais téléversés directement sur la carte : la carte reçoit toujours le vrai code du projet, que tu copies dans l'Arduino IDE pour Arduino et ESP32, ou dans Thonny pour le Pico. Tu peux filtrer la liste des projets par badge blocs et retrouver tous les projets en blocs pour Arduino, ESP32 et Pico sur la page programmation par blocs.

Avec le port série et la lecture de capteurs, tu sais désormais lire toutes les briques de base d'un projet, en blocs comme en code. La dernière partie de la série emmène ces étapes en classe : un plan de cours de robotique en programmation par blocs pour les enseignants. D'ici là, tu peux parcourir pas à pas dans l'application BlueGrays les schémas et le code des projets LDR, HC-SR04 et LED sur Pico, passer à la version en blocs du même programme avec Voir en blocs, et suivre ce que fait chaque étape avec Comprendre les blocs.