mBlock Arduino : installation, mode en direct et téléversement

Programmer un Arduino avec mBlock est l'un des moyens les plus simples de faire clignoter une LED sur un Arduino Uno ou de lire un bouton et des capteurs sans écrire une seule ligne de code. mBlock 5, développé gratuitement par Makeblock, est un environnement de programmation par blocs basé sur Scratch 3.0 : tu assembles des blocs colorés comme un puzzle, et mBlock les traduit en coulisses en code Arduino C, le compile et le téléverse dans ta carte. Tu peux aussi exécuter les blocs instantanément sur la carte et les faire interagir avec les personnages de la scène. C'est pourquoi il fait partie des outils les plus utilisés en cours de robotique et de technologie, pour les projets de concours scientifiques et pour les premiers pas avec Arduino.

Dans ce guide, tu verras étape par étape comment installer mBlock sur ton ordinateur ou l'utiliser dans le navigateur, ajouter et connecter un Arduino Uno comme appareil, installer le firmware du mode en direct, la différence entre le mode en direct et le mode téléversement, les blocs pour LED, bouton et capteurs, les lignes d'Arduino C que produisent les blocs, neuf activités à faire en classe, le passage à l'Arduino IDE et les solutions aux problèmes de connexion les plus fréquents.

Qu'est-ce que mBlock et comment fonctionne-t-il avec Arduino ?

mBlock est un environnement de programmation construit sur Scratch 3.0, développé au MIT. Sa grande différence avec Scratch : en plus des personnages à l'écran (les sprites), il peut programmer du vrai matériel. L'interface comporte deux onglets distincts : dans l'onglet Sprites, tu programmes les personnages de la scène, et dans l'onglet Devices (appareils), des cartes comme Arduino, micro:bit ou les robots Makeblock. Quand tu choisis un appareil, des catégories propres à cette carte s'ajoutent à la palette de blocs ; pour l'Arduino Uno, ce sont les blocs de broches et de port série. En mode téléversement, ton script de blocs est traduit en Arduino C, compilé en code machine puis écrit par USB dans la mémoire flash de la carte. Autrement dit, mBlock fait le même travail que l'Arduino IDE avec une interface en blocs, et comme il te montre le code qu'il génère, il facilite aussi le passage au code texte.

Installer mBlock : version de bureau et version web

1. Dans ton navigateur, va sur mblock.cc et télécharge depuis la page Download la version de bureau de mBlock 5 pour ton système d'exploitation. Au moment de la rédaction, la version actuelle est la V5.6 ; elle prend en charge Windows 7 et versions ultérieures en 64 bits ainsi que macOS 10.12 et versions ultérieures, avec un installateur à part pour les Mac à puce Apple M.
2. Sous Windows, lance le programme d'installation et suis l'assistant. S'il propose d'installer le pilote CH340, accepte : la plupart des clones d'Arduino utilisent cette puce USB-série, et sans pilote le port n'apparaît pas.
3. Sous macOS, si le fichier d'installation refuse de s'ouvrir, fais un clic droit dessus et choisis Ouvrir, ou utilise le bouton Ouvrir quand même dans Confidentialité et sécurité des Réglages Système.
4. Ouvre mBlock et choisis Français via l'icône du globe dans le menu du haut. Les menus et les noms des blocs s'affichent alors en français.
5. Sur les ordinateurs de l'école où tu ne peux rien installer, ouvre ide.mblock.cc dans le navigateur ; pour la connexion à l'Arduino, utilise une version à jour de Chrome ou d'Edge.

Pendant longtemps, la version web se connectait à la carte grâce à un petit programme d'aide appelé mLink. Dans les versions récentes, la méthode par défaut est la connexion directe, qui utilise la fonction port série du navigateur : quand tu cliques sur connecter, le navigateur ouvre une fenêtre, tu choisis le port de l'Arduino et tu es connecté sans rien installer de plus. Cette méthode fonctionne avec l'Uno, la Nano, la Nano (old) et la Mega 2560 ; les cartes qui utilisent l'USB autrement, comme la Leonardo, la Micro et la Yun, ont toujours besoin de mLink. Quand mLink tourne, une petite icône de panda apparaît dans la barre des tâches. Ne garde pas la version de bureau et la version web, ni deux onglets mBlock, ouverts en même temps : les deux essaient d'utiliser le même port et la connexion échoue.

Ajouter un appareil : connecter l'Arduino Uno à mBlock

1. Branche l'Arduino à l'ordinateur avec un câble USB ; la LED ON (alimentation) de la carte doit s'allumer.
2. Dans mBlock, passe à l'onglet Devices (appareils) sous la scène. Supprime l'appareil Makeblock présent par défaut (Codey Rocky ou CyberPi selon la version) avec la croix dans son coin.
3. Clique sur + Add (ajouter), tape "Arduino" dans le champ de recherche de la bibliothèque d'appareils, choisis Arduino Uno et clique sur OK. Si tu cliques sur l'étoile en haut à gauche de la carte, mBlock l'aura sous la main au prochain démarrage.
4. Clique sur Connect (connecter). Dans l'onglet USB de la fenêtre qui s'ouvre, choisis le port trouvé par mBlock : sous Windows, un nom comme COM3 ou COM4 ; sous macOS, quelque chose comme /dev/cu.usbmodem… ou, sur les cartes avec CH340, /dev/cu.wchusbserial…. Si le port n'apparaît pas, coche Show all connectable devices (afficher tous les appareils connectables).
5. Clique à nouveau sur Connect. Si le message "Device connected" (appareil connecté) s'affiche, c'est prêt ; les blocs de broches et de port série propres à l'Arduino apparaissent dans la palette.

Bien choisir l'appareil, c'est la moitié du travail. Carte originale ou clone, choisis Arduino Uno pour une Uno et Arduino Mega2560 pour une Mega. La plupart des clones bon marché d'Arduino Nano ont l'ancien bootloader : sur ces cartes, le téléversement échoue avec Arduino Nano, alors que l'option Arduino Nano (old) fonctionne. Les cartes récentes à processeur différent, comme l'Arduino Uno R4, ne se programment pas avec l'appareil Uno de mBlock ; pour elles, utilise directement l'Arduino IDE. Si tu ne sais pas encore quelle carte acheter, lis Quel Arduino choisir ?, et pour le brochage de la Nano, consulte le guide du brochage de l'Arduino Nano.

Mode en direct ou mode téléversement : quelle différence ?

mBlock propose deux modes pour programmer les appareils, et tu passes de l'un à l'autre avec l'interrupteur de l'onglet Devices. En mode en direct (Live), le programme tourne en réalité sur l'ordinateur : mBlock lit les blocs un par un et envoie à l'Arduino, par USB, des commandes comme "allume la broche 13" ou "lis A0 et renvoie-moi le résultat". Pour cela, l'Arduino doit contenir un firmware spécial qui comprend ces commandes. Le résultat est immédiat, tu peux suivre les valeurs des capteurs sur la scène et faire dialoguer l'Arduino avec les sprites, mais dès que tu débranches le câble USB ou fermes mBlock, le programme s'arrête. En mode téléversement (Upload), les blocs sont traduits en Arduino C, compilés et écrits durablement dans la carte ; même câble débranché, le programme continue de tourner sur pile ou sur adaptateur. Dans ce mode, ton programme doit être placé sous le bloc chapeau when Arduino Uno starts up (quand l'Arduino Uno démarre) ; les événements de la scène comme le drapeau vert ne sont pas transmis à la carte.

Installer le firmware : préparer l'Arduino pour le mode en direct

1. Connecte l'Arduino (Connect) et mets l'interrupteur de mode sur Live (en direct).
2. Si la carte n'a pas le firmware mBlock, mBlock propose en général de le mettre à jour. Sinon, choisis Update Firmware (mise à jour du firmware) dans le menu Setting (réglages) à côté des boutons de connexion et lance la mise à jour dans la fenêtre qui s'ouvre.
3. Pendant l'installation, les LED TX et RX de la carte clignotent rapidement ; ne débranche pas le câble et ne ferme pas mBlock avant la fin de la barre de progression.
4. Pour tester, fais glisser le bloc set digital pin (13) output as (high) des blocs de broches vers la zone de script et clique une fois dessus. Si la LED L de la carte s'allume aussitôt, le mode en direct fonctionne ; clique sur le même bloc avec l'option (low) et la LED s'éteint.

Blocs Arduino de base : LED, bouton et capteurs

Une fois l'Arduino Uno ajouté, la palette reçoit des catégories propres à la carte pour les broches et le port série, à côté des catégories Events (événements), Control (contrôle), Operators (opérateurs), Variables et My Blocks (mes blocs) que tu connais depuis Scratch. Avec l'interface en français, les blocs portent des noms français ; pour que tu t'y retrouves, le tableau ci-dessous donne leurs noms anglais et ce qu'ils font. Les noms peuvent légèrement varier selon la version ; si tu fais un clic droit sur un bloc et choisis Help (aide), mBlock affiche sa description. Sur l'Uno, le PWM ne fonctionne que sur les broches 3, 5, 6, 9, 10 et 11 ; tu trouveras le brochage complet dans l'outil Pinout.

Tableau de câblage : un seul montage pour toutes les activités

Refaire le circuit chaque semaine fait perdre du temps de cours. Si tu montes une fois le câblage ci-dessous sur une plaque d'essai, tu pourras faire les neuf activités sans toucher un fil. Tu peux vérifier la résistance de la LED avec le calculateur de résistance pour LED et la tension fournie par le pont diviseur de la LDR avec l'outil pont diviseur de tension. Si tu utilises ces composants pour la première fois, les articles sur la LED, le bouton-poussoir, la LDR et le servomoteur détaillent chaque branchement.

Premier programme : faire clignoter une LED en mode téléversement

1. Mets l'interrupteur de mode sur Upload (téléversement).
2. Fais glisser le bloc when Arduino Uno starts up de la catégorie Events dans la zone de script.
3. Accroche en dessous un bloc forever (répéter indéfiniment) de la catégorie Control.
4. Dans le bloc forever, place dans l'ordre set digital pin (13) output as (high), wait (1) seconds, set digital pin (13) output as (low) puis encore wait (1) seconds.
5. Clique sur Upload (téléverser). mBlock compile le code et l'envoie à la carte ; après quelques secondes, un message indique que le téléversement est terminé.
6. La LED L de la carte se met à clignoter toutes les secondes. Si tu débranches le câble USB et alimentes la carte avec une batterie externe ou un adaptateur 7–12 V, le programme continue ; nous détaillons les options d'alimentation dans alimenter un Arduino sur pile.

Comment les blocs deviennent-ils du code Arduino C ?

En mode téléversement, clique sur le bouton de code Arduino C sur le bord droit (l'icône avec des chevrons) : mBlock affiche dans un panneau le code correspondant à tes blocs. Chaque modification des blocs met le code à jour instantanément ; c'est le moyen le plus simple d'apprendre quel bloc produit quelle ligne. Si tu ajoutes au programme Blink ci-dessus une variable nommée sayac (compteur) et que tu l'augmentes de 1 à chaque tour, le code généré ressemble à ceci. Nous avons ajouté les lignes de commentaire ; les espaces et la position de certaines lignes, comme pinMode, peuvent varier un peu selon la version.

1// generated by mBlock5 for <your product>
2// codes make you happy
3// mBlock'un ürettiği kodun yapısı: Blink + sayaç / Structure of mBlock-generated code: Blink + counter
4
5#include <Arduino.h>
6#include <Wire.h>
7#include <SoftwareSerial.h>
8
9float sayac = 0;               // mBlock değişkenleri float olur / mBlock variables become float
10
11void _loop();                  // ön bildirim, Arduino IDE de ekler / forward declaration, the Arduino IDE adds it too
12
13void _delay(float seconds) {   // "wait (1) seconds" bloğu / the "wait (1) seconds" block
14  long endTime = millis() + seconds * 1000;
15  while (millis() < endTime) _loop();
16}
17
18void setup() {                 // "when Arduino Uno starts up" altındaki bloklar / blocks under "when Arduino Uno starts up"
19  pinMode(13, OUTPUT);
20  while (1) {                  // "forever" bloğu / the "forever" block
21    digitalWrite(13, 1);       // pin 13 HIGH: dahili L LED'i yanar / pin 13 HIGH: the built-in L LED turns on
22    _delay(1);
23    digitalWrite(13, 0);       // pin 13 LOW: LED söner / pin 13 LOW: the LED turns off
24    _delay(1);
25    sayac += 1;                // "change sayac by 1" bloğu / the "change sayac by 1" block
26    _loop();
27  }
28}
29
30void _loop() {                 // uzantıların sürekli çalışan kodu buraya eklenir / extensions add their recurring code here
31}
32
33void loop() {
34  _loop();
35}

Quatre points sont à remarquer dans ce code. D'abord, le bloc forever ne devient pas la fonction loop() de l'Arduino, mais une boucle infinie while(1) dans setup() ; loop() se contente d'appeler la fonction _loop(). Ensuite, le bloc wait utilise une fonction _delay() au lieu de delay() ; pendant l'attente, elle continue d'appeler _loop(), pour que les tâches de fond de certaines extensions ne soient pas bloquées. Troisièmement, chaque variable créée dans mBlock est déclarée en float (nombre à virgule) ; sur l'Uno, chacune occupe 4 octets de RAM et peut causer de petites erreurs d'arrondi lors des comparaisons d'égalité. Par exemple, une variable que tu augmentes par pas de 0,1 ne vaut pas forcément exactement 1 après dix pas ; une comparaison "plus grand que" ou "plus petit que" est donc plus sûre que "égal à". Enfin, les bibliothèques Wire et SoftwareSerial en tête du code sont généralement incluses même si tu ne t'en sers pas ; le programme fonctionne quand même, mais il peut occuper un peu plus de place qu'une version écrite à la main.

Activités pour les cours de robotique et de programmation

Les neuf activités ci-dessous sont classées de la plus simple à la plus difficile pour des séances de 40 minutes, et toutes fonctionnent avec le montage unique ci-dessus. Commencer chaque activité en mode en direct est une bonne méthode : les élèves cliquent sur un bloc, voient le résultat immédiatement, suivent les valeurs des capteurs sur la scène et trouvent eux-mêmes leurs erreurs. Une fois le programme au point, passer les mêmes blocs en mode téléversement et les écrire durablement dans la carte leur fait découvrir l'idée d'"un appareil qui fonctionne sans ordinateur". Tu retrouveras les notions de programmation de ces activités en code texte dans l'article bases de la programmation Arduino.

Les conversions de nombres sont la partie la plus formatrice des séances. Le potentiomètre donne une valeur de 0 à 1023 alors que le PWM attend 0 à 255 ; dans l'activité 5, tu divises donc la mesure par 4 (1023 ÷ 4 ≈ 255). Pour transformer cette même valeur en angle pour le servo, tu construis valeur × 180 ÷ 1023 avec les blocs opérateurs. Dans l'activité 9, tu donnes à l'Arduino, en mode en direct, le script "when green flag clicked, forever, set [pot] to (read analog pin A1)" ; sur le sprite, tu utilises la même variable dans un bloc set x to (pot × 480 ÷ 1023 − 240) pour répartir la raquette sur toute la largeur de la scène, de −240 à 240. Si tu ne coches pas l'option "pour tous les sprites" en créant la variable, l'appareil et le sprite ne voient pas la même variable. Pour le radar de recul, ouvre le centre d'extensions avec le bouton + extension en bas de la palette et ajoute une extension de capteur à ultrasons ; la plupart de ces extensions sont faites par des développeurs de la communauté, si bien que les noms des blocs et les broches prises en charge changent d'une extension à l'autre. Tu trouveras le fonctionnement du capteur dans l'article sur le capteur de distance HC-SR04 et les fréquences des notes dans celui sur le buzzer.

Passer à l'Arduino IDE : des blocs au vrai code

Un jour, les blocs ne suffisent plus : le programme grossit et la zone de script devient confuse, il te faut une bibliothèque de capteur absente du centre d'extensions, ou tu veux mener plusieurs tâches en parallèle sans delay. C'est le moment de passer par l'installation de l'Arduino IDE et au code texte ; l'ajout de bibliothèques pour de nouveaux capteurs est alors entre tes mains. Le meilleur moyen d'adoucir la transition est de réécrire dans l'Arduino IDE un projet fait dans mBlock : tu vois ainsi deux versions de la même logique côte à côte.

1. Dans mBlock, sélectionne et copie le code du panneau Arduino C ; ouvre un nouveau croquis dans l'Arduino IDE et colle-le.
2. Dans le menu Outils, choisis la carte (Arduino Uno) et le port, puis clique d'abord sur Vérifier et ensuite sur Téléverser. Le code doit fonctionner exactement comme dans mBlock.
3. Simplifie ensuite le code : regroupe les lignes pinMode dans setup(), déplace le contenu de la boucle while(1) dans loop() et utilise delay() ou millis() à la place de _delay().
4. Transforme les variables float en int ou en bool selon le besoin et donne des noms parlants aux numéros de broches avec const int.
5. Affiche les variables dans le moniteur série pour suivre ce que fait le programme ; c'est l'équivalent, en code texte, du suivi en direct de mBlock.

Voici le programme qui réunit les activités 3 et 4, une veilleuse automatique que tu allumes et éteins avec un bouton, écrit pour l'Arduino IDE. Les numéros de broches correspondent au tableau de câblage ci-dessus.

1// mBlock gece lambası etkinliğinin Arduino IDE ile yazılmış hali
2// The mBlock night-light activity rewritten for the Arduino IDE
3const int LED_PIN = 5;         // LED + 220 ohm direnç (PWM pini) / LED + 220 ohm resistor (PWM pin)
4const int BUTON_PIN = 2;       // buton 5V'a, 10k pull-down GND'ye / button to 5V, 10k pull-down to GND
5const int LDR_PIN = A0;        // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
6const int ESIK = 400;          // bu değerin altı "karanlık" sayılır / below this value counts as "dark"
7
8bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
9int oncekiButon = LOW;         // önceki buton durumu / previous button state
10unsigned long sonYazma = 0;    // son Seri Monitör yazma zamanı / last Serial Monitor print time
11
12void setup() {
13  pinMode(LED_PIN, OUTPUT);
14  pinMode(BUTON_PIN, INPUT);   // harici pull-down olduğu için INPUT / INPUT because of the external pull-down
15  Serial.begin(9600);          // Seri Monitör 9600 baud / Serial Monitor at 9600 baud
16}
17
18void loop() {
19  int buton = digitalRead(BUTON_PIN);
20  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
21    sistemAcik = !sistemAcik;
22    delay(30);                                 // basit debounce / simple debounce
23  }
24  oncekiButon = buton;
25
26  int isik = analogRead(LDR_PIN);              // 0 karanlık, 1023 aydınlık / 0 dark, 1023 bright
27  if (sistemAcik && isik < ESIK) {
28    int parlaklik = map(isik, 0, ESIK, 255, 40);   // karardıkça daha parlak / brighter as it gets darker
29    analogWrite(LED_PIN, parlaklik);
30  } else {
31    analogWrite(LED_PIN, 0);
32  }
33
34  if (millis() - sonYazma >= 500) {            // delay olmadan yarım saniyede bir yaz / print every half second without delay
35    sonYazma = millis();
36    Serial.print("Isik: ");
37    Serial.print(isik);
38    Serial.print("  Sistem: ");
39    Serial.println(sistemAcik ? "acik" : "kapali");
40  }
41}

Observe les différences avec la version mBlock : setup() ne s'exécute qu'une fois pour préparer les broches, tandis que loop() se répète toute seule, d'où l'inutilité de while(1). Le bouton est comparé à son état précédent et n'est pris en compte qu'au moment de l'appui ; sinon, tant que ton doigt resterait dessus, le système basculerait des centaines de fois par seconde. La fonction map() met la valeur de la LDR à l'échelle entre 255 et 40, si bien que la LED brille davantage quand la pièce s'assombrit. L'affichage dans le moniteur série se fait toutes les demi-secondes avec millis() au lieu de delay(), pour que le programme ne rate pas un appui pendant qu'il attend. Les détails de cette technique sont dans millis ou delay, et l'affichage de données dans l'article sur le moniteur série Arduino.

Le même programme sur ESP32 et Raspberry Pi Pico

La bibliothèque d'appareils de mBlock contient les cartes Makeblock à base d'ESP32, comme CyberPi et HaloCode, mais aucun appareil officiel pour une carte de développement ESP32 ordinaire ni pour la Raspberry Pi Pico ; les extensions de la communauté qu'on croise parfois changent en plus d'une version à l'autre. La bonne nouvelle, c'est que la logique apprise avec les blocs ne change pas d'une carte à l'autre. En programmant l'ESP32 avec l'Arduino IDE, tu utilises presque le même code ; seuls changent les numéros de broches, la tension de fonctionnement de 3,3 V et l'échelle 12 bits de l'ADC, de 0 à 4095. C'est pourquoi le seuil d'obscurité passe de 400 à environ 1600.

1// Aynı gece lambası ESP32'de (Arduino IDE) / The same night light on the ESP32 (Arduino IDE)
2const int LED_PIN = 18;        // LED + 220 ohm direnç / LED + 220 ohm resistor
3const int BUTON_PIN = 4;       // buton 3V3'e, 10k pull-down GND'ye / button to 3V3, 10k pull-down to GND
4const int LDR_PIN = 34;        // ADC1 girişi, LDR + 10k bölücü (3V3) / ADC1 input, LDR + 10k divider (3V3)
5const int ESIK = 1600;         // ESP32 ADC 12 bit: 0-4095 / ESP32 ADC is 12-bit: 0-4095
6
7bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
8int oncekiButon = LOW;         // önceki buton durumu / previous button state
9unsigned long sonYazma = 0;    // son yazma zamanı / last print time
10
11void setup() {
12  pinMode(LED_PIN, OUTPUT);
13  pinMode(BUTON_PIN, INPUT);   // harici pull-down / external pull-down
14  Serial.begin(115200);        // ESP32 için yaygın hız / common speed for the ESP32
15}
16
17void loop() {
18  int buton = digitalRead(BUTON_PIN);
19  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
20    sistemAcik = !sistemAcik;
21    delay(30);                                 // basit debounce / simple debounce
22  }
23  oncekiButon = buton;
24
25  int isik = analogRead(LDR_PIN);              // 0 karanlık, 4095 aydınlık / 0 dark, 4095 bright
26  if (sistemAcik && isik < ESIK) {
27    analogWrite(LED_PIN, map(isik, 0, ESIK, 255, 40));   // karardıkça daha parlak / brighter as it gets darker
28  } else {
29    analogWrite(LED_PIN, 0);
30  }
31
32  if (millis() - sonYazma >= 500) {            // yarım saniyede bir yaz / print every half second
33    sonYazma = millis();
34    Serial.printf("Isik: %d  Sistem: %s\n", isik, sistemAcik ? "acik" : "kapali");
35  }
36}

Sur la Raspberry Pi Pico, la voie la plus courante est MicroPython. Le programme ci-dessous, à lancer dans l'éditeur Thonny, fait le même travail : read_u16() renvoie la valeur de l'ADC de 0 à 65535, et duty_u16() attend le rapport cyclique du PWM sur la même échelle. Nous expliquons pourquoi Python est une bonne deuxième étape après la programmation par blocs dans l'article sur les bases de MicroPython.

1# Aynı gece lambası Raspberry Pi Pico'da (MicroPython) / The same night light on Raspberry Pi Pico (MicroPython)
2from machine import Pin, ADC, PWM
3import time
4
5led = PWM(Pin(14))                     # LED + 220 ohm direnç / LED + 220 ohm resistor
6led.freq(1000)                         # PWM frekansı 1 kHz / PWM frequency 1 kHz
7buton = Pin(2, Pin.IN, Pin.PULL_DOWN)  # buton 3V3'e, pull-down / button to 3V3, pull-down
8ldr = ADC(26)                          # GP26 = ADC0, LDR + 10k bölücü / GP26 = ADC0, LDR + 10k divider
9ESIK = 25000                           # 0-65535 arası karanlık eşiği / darkness threshold on 0-65535
10
11sistem_acik = True                     # butonla açılıp kapanır / toggled with the button
12onceki = 0                             # önceki buton durumu / previous button state
13son_yazma = time.ticks_ms()            # son yazma zamanı / last print time
14
15while True:
16    b = buton.value()
17    if b == 1 and onceki == 0:         # yalnız basıldığı an / only at the moment of the press
18        sistem_acik = not sistem_acik
19        time.sleep_ms(30)              # basit debounce / simple debounce
20    onceki = b
21
22    isik = ldr.read_u16()              # 0 karanlık, 65535 aydınlık / 0 dark, 65535 bright
23    if sistem_acik and isik < ESIK:
24        # karardıkça daha parlak / brighter as it gets darker
25        led.duty_u16(65535 - isik * 55000 // ESIK)
26    else:
27        led.duty_u16(0)
28
29    if time.ticks_diff(time.ticks_ms(), son_yazma) >= 500:   # yarım saniyede bir / every half second
30        son_yazma = time.ticks_ms()
31        print("Isik:", isik, " Sistem:", "acik" if sistem_acik else "kapali")

Ouvrir les mêmes projets en blocs sur ton téléphone

Si tu veux continuer avec la logique de blocs construite dans mBlock quand tu n'es pas devant l'ordinateur, jette un œil à l'application BlueGrays. Le code de plus de 100 projets Arduino, ESP32 et Raspberry Pi Pico de l'application existe aussi dans nos propres blocs basés sur Blockly. Active Voir en blocs sur un projet et le même programme apparaît en blocs à la place du code ; l'onglet Comprendre les blocs explique ensuite pas à pas ce que fait chaque bloc. Les activités LED, feu tricolore, LED avec bouton, veilleuse à LDR, buzzer, radar de recul et servo avec potentiomètre de ce guide y sont toutes, en blocs et en code Arduino C, et tu passes de l'un à l'autre d'une touche. Comparer la séquence que tu as construite dans mBlock avec les blocs de l'application est un moyen simple de voir comment la même logique se construit dans deux outils différents.

Pour l'ESP32 et la Pico, qui n'ont pas d'appareil officiel dans mBlock comme on l'a vu plus haut, l'application propose aussi des projets en blocs : regarde d'abord la version en blocs, puis passe au code Arduino C ou MicroPython du même projet. Dans le Guide du code de l'application, les exemples des commandes de base comme digitalWrite, if/else et les boucles sont aussi montrés en blocs. Pour consolider ce que tu as appris, Questions du jour te propose 5 questions par jour sur des niveaux de A1 à C2, avec un classement hebdomadaire et des badges.

Problèmes de connexion fréquents et solutions

Pour savoir rapidement si le problème vient de mBlock ou de la carte, essaie de téléverser l'exemple Blink sur la même carte avec l'Arduino IDE. Si l'Arduino IDE affiche lui aussi une erreur comme avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00, la carte et l'ordinateur n'arrivent pas à communiquer : le problème vient du port, du câble, du type de carte ou du bootloader. Nous passons en revue toutes les causes de cette erreur dans le guide Arduino : le téléversement échoue ; pour en savoir plus sur la puce CH340 et ses pilotes, consulte l'article sur le convertisseur USB-TTL. Si la carte redémarre toute seule quand un servo est branché, les conseils d'alimentation de Arduino redémarre tout seul t'aideront.

Idées de projets avec mBlock

• Feu tricolore avec bouton piéton : un appui fait passer le feu des voitures au rouge et allume le vert des piétons ; pour le circuit et le code, vois l'article feu tricolore Arduino.
• Radar de recul : un bip qui s'accélère et de plus en plus de LED allumées à mesure que le HC-SR04 mesure une distance plus courte.
• Robot éviteur d'obstacles : une voiture à deux moteurs et un capteur de distance qui voit l'obstacle devant elle et change de direction ; détails dans le guide du robot éviteur d'obstacles.
• Robot suiveur de ligne : un robot de compétition qui suit un ruban noir grâce à des capteurs infrarouges (robot suiveur de ligne).
• Manette pour la scène : un jeu en mode en direct où un potentiomètre ou un joystick pilote un vaisseau spatial sur la scène.
• Arrosage automatique des plantes : un système qui met en marche une petite pompe quand un capteur d'humidité du sol détecte une terre sèche.
• Radar à servo : un projet qui balaie les alentours avec un capteur de distance monté sur un servo et dessine un écran radar sur la scène (radar Arduino).
• Voiture robot : transpose la logique moteurs et capteurs apprise dans mBlock au projet fabriquer une voiture robot Arduino.

mBlock est la façon la plus douce de programmer un vrai Arduino avec le confort des blocs, puis de passer au code texte quand tu es prêt. Si tu n'as pas encore de carte, tu peux essayer les mêmes activités dans le navigateur avec la simulation Arduino sur Tinkercad. Dans l'application BlueGrays, tu trouveras des schémas de câblage pas à pas et le code des projets LED, feu tricolore, LED avec bouton, veilleuse à LDR, buzzer, radar de recul HC-SR04 et servo avec potentiomètre, et tu peux aussi ouvrir ces mêmes projets en blocs : tu compares d'une touche la version en blocs et la version en code texte de chaque activité construite dans mBlock.