mBlock Arduino: installazione, modalità live e caricamento codice

Programmare Arduino con mBlock è uno dei modi più semplici per far lampeggiare un LED su un Arduino Uno o leggere un pulsante e dei sensori senza scrivere una sola riga di codice. mBlock 5, sviluppato gratuitamente da Makeblock, è un ambiente di programmazione a blocchi basato su Scratch 3.0: unisci blocchi colorati come in un puzzle e mBlock li traduce dietro le quinte in codice Arduino C, lo compila e lo carica sulla tua scheda. Se vuoi, puoi anche eseguire i blocchi sulla scheda all'istante e farli interagire con i personaggi dello stage. Per questo è uno degli strumenti più usati nelle lezioni di robotica e coding a scuola, nei progetti per concorsi scientifici e come primo passo con Arduino.

In questa guida vedrai passo passo come installare mBlock sul computer o usarlo nel browser, aggiungere e collegare un Arduino Uno come dispositivo, caricare il firmware per la modalità live, la differenza tra modalità live e modalità caricamento, i blocchi per LED, pulsante e sensori, in quali righe di Arduino C si trasformano i blocchi, nove attività da usare in classe, il passaggio all'Arduino IDE e come risolvere i problemi di connessione più comuni.

Che cos'è mBlock e come funziona con Arduino?

mBlock è un ambiente di programmazione costruito sopra Scratch 3.0, sviluppato al MIT. La differenza più grande rispetto a Scratch è che, oltre ai personaggi sullo schermo (gli sprite), può programmare anche hardware reale. L'interfaccia ha due schede separate: nella scheda Sprites programmi i personaggi dello stage, nella scheda Devices (dispositivi) programmi schede come Arduino, micro:bit o i robot Makeblock. Quando scegli un dispositivo, alla tavolozza dei blocchi si aggiungono categorie specifiche per quella scheda; per l'Arduino Uno sono i blocchi dei pin e della porta seriale. In modalità caricamento il tuo script a blocchi viene tradotto in Arduino C, compilato in codice macchina e scritto via USB nella memoria flash della scheda. In altre parole, mBlock fa lo stesso lavoro dell'Arduino IDE con un'interfaccia a blocchi e, siccome ti mostra il codice che genera, rende più facile anche il passaggio al codice testuale.

Installare mBlock: versione desktop e versione web

1. Nel browser vai su mblock.cc e scarica dalla pagina Download la versione desktop di mBlock 5 per il tuo sistema operativo. Al momento della stesura la versione attuale è la V5.6; sono supportati Windows 7 e successivi a 64 bit e macOS 10.12 e successivi, con un programma di installazione a parte per i Mac con chip Apple M.
2. Su Windows avvia il programma di installazione e segui la procedura guidata. Se durante l'installazione ti propone il driver CH340, accetta: la maggior parte dei cloni di Arduino usa questo chip USB-seriale e senza driver la porta non compare.
3. Su macOS, se il file di installazione non si apre, fai clic destro sul file e scegli Apri, oppure usa il pulsante Apri comunque in Privacy e sicurezza delle Impostazioni di Sistema.
4. Apri mBlock e scegli Italiano dall'icona del globo nel menu in alto. Da quel momento menu e nomi dei blocchi appaiono in italiano.
5. Sui computer della scuola dove non puoi installare programmi, apri ide.mblock.cc nel browser; per collegare Arduino usa una versione aggiornata di Chrome o Edge.

Per molto tempo la versione web si collegava alla scheda tramite un piccolo programma di supporto chiamato mLink. Nelle versioni recenti il metodo predefinito è la connessione diretta, che usa la funzione porta seriale del browser: quando fai clic su connetti, il browser apre una finestra, scegli la porta dell'Arduino e sei collegato senza installare altro. Funziona con Uno, Nano, Nano (old) e Mega 2560; le schede che usano l'USB in modo diverso, come Leonardo, Micro e Yun, hanno ancora bisogno di mLink. Mentre mLink è in esecuzione, nella barra delle applicazioni compare una piccola icona a forma di panda. Non tenere aperte insieme la versione desktop e quella web, né due schede di mBlock: entrambe cercano di usare la stessa porta e la connessione non riesce.

Aggiungere un dispositivo: collegare l'Arduino Uno a mBlock

1. Collega l'Arduino al computer con un cavo USB; il LED ON (alimentazione) della scheda deve accendersi.
2. In mBlock passa alla scheda Devices (dispositivi) sotto lo stage. Rimuovi il dispositivo Makeblock presente di default (Codey Rocky o CyberPi, a seconda della versione) con la crocetta nel suo angolo.
3. Fai clic su + Add (aggiungi), scrivi "Arduino" nella casella di ricerca della libreria dei dispositivi, scegli Arduino Uno e fai clic su OK. Se fai clic sulla stella nell'angolo in alto a sinistra della scheda, mBlock la terrà pronta al prossimo avvio.
4. Fai clic su Connect (connetti). Nella scheda USB della finestra che si apre, scegli la porta trovata da mBlock: su Windows vedrai un nome come COM3 o COM4, su macOS qualcosa come /dev/cu.usbmodem… oppure, sulle schede con CH340, /dev/cu.wchusbserial…. Se la porta non compare, spunta Show all connectable devices (mostra tutti i dispositivi collegabili).
5. Fai di nuovo clic su Connect. Se compare il messaggio "Device connected" (dispositivo connesso) sei pronto; nella tavolozza compaiono i blocchi dei pin e della porta seriale specifici di Arduino.

Scegliere il dispositivo giusto è metà del lavoro. Che sia originale o clone, scegli Arduino Uno per un Uno e Arduino Mega2560 per un Mega. La maggior parte dei cloni economici di Arduino Nano ha il vecchio bootloader: su queste schede il caricamento fallisce con Arduino Nano, mentre l'opzione Arduino Nano (old) funziona. Le schede nuove con un processore diverso, come l'Arduino Uno R4, non si possono programmare con il dispositivo Uno di mBlock; per queste usa direttamente l'Arduino IDE. Se non hai ancora deciso quale scheda comprare, leggi Quale Arduino comprare?, e per la piedinatura del Nano consulta la guida ai pin dell'Arduino Nano.

Modalità live e modalità caricamento: la differenza

mBlock offre due modalità per programmare i dispositivi, e passi dall'una all'altra con l'interruttore nella scheda Devices. In modalità live (Live) il programma in realtà gira sul computer: mBlock legge i blocchi uno alla volta e invia all'Arduino, via USB, comandi come "accendi il pin 13" o "leggi A0 e mandami il risultato". Per questo l'Arduino deve avere un firmware speciale che capisca questi comandi. Il risultato si vede subito, puoi seguire i valori dei sensori sullo stage e far dialogare l'Arduino con gli sprite, ma appena scolleghi il cavo USB o chiudi mBlock il programma si ferma. In modalità caricamento (Upload) i blocchi vengono tradotti in Arduino C, compilati e scritti in modo permanente sulla scheda; anche senza cavo il programma continua a funzionare con una batteria o un alimentatore. In questa modalità il programma deve stare sotto il blocco cappello when Arduino Uno starts up (quando Arduino Uno si avvia); gli eventi dello stage, come la bandiera verde, non passano alla scheda.

Caricare il firmware: preparare l'Arduino per la modalità live

1. Collega l'Arduino (Connect) e porta l'interruttore della modalità su Live.
2. Se la scheda non ha il firmware di mBlock, di solito mBlock propone di aggiornarlo. In caso contrario scegli Update Firmware (aggiorna firmware) dal menu Setting (impostazioni) accanto ai pulsanti di connessione e avvia l'aggiornamento nella finestra che si apre.
3. Durante il caricamento i LED TX e RX della scheda lampeggiano velocemente; non scollegare il cavo e non chiudere mBlock finché la barra di avanzamento non è completa.
4. Per provare, trascina il blocco set digital pin (13) output as (high) dai blocchi dei pin nell'area degli script e cliccaci sopra una volta. Se il LED L della scheda si accende subito, la modalità live funziona; cliccando lo stesso blocco con l'opzione (low) il LED si spegne.

Blocchi Arduino di base: LED, pulsante e sensori

Quando aggiungi l'Arduino Uno, la tavolozza riceve categorie specifiche della scheda per i pin e la porta seriale, accanto alle categorie Events (situazioni), Control (controllo), Operators (operatori), Variables (variabili) e My Blocks (i miei blocchi) che conosci da Scratch. Con l'interfaccia in italiano i blocchi hanno nomi italiani; per non confonderti, nella tabella qui sotto trovi i nomi inglesi e cosa fa ciascun blocco. I nomi possono variare leggermente a seconda della versione; se fai clic destro su un blocco e scegli Help (aiuto), mBlock ne mostra la descrizione. Sull'Uno il PWM funziona solo sui pin 3, 5, 6, 9, 10 e 11; la mappa completa dei pin è nello strumento Pinout.

Tabella dei collegamenti: un unico montaggio per tutte le attività

Rifare il circuito ogni settimana fa perdere tempo di lezione. Se monti una volta sola sulla breadboard i collegamenti qui sotto, puoi fare tutte e nove le attività senza toccare un cavo. Puoi verificare la resistenza del LED con il calcolatore della resistenza per LED e la tensione data dal partitore della LDR con lo strumento partitore di tensione. Se usi questi componenti per la prima volta, negli articoli su LED, pulsante, LDR e servomotore trovi il collegamento dettagliato di ciascuno.

Primo programma: far lampeggiare un LED in modalità caricamento

1. Porta l'interruttore della modalità su Upload (caricamento).
2. Trascina nell'area degli script il blocco when Arduino Uno starts up dalla categoria Events.
3. Aggancia sotto un blocco forever (per sempre) dalla categoria Control.
4. Dentro forever metti in ordine set digital pin (13) output as (high), wait (1) seconds, set digital pin (13) output as (low) e di nuovo wait (1) seconds.
5. Fai clic su Upload (carica). mBlock compila il codice e lo invia alla scheda; dopo qualche secondo un messaggio ti avvisa che il caricamento è finito.
6. Il LED L della scheda inizia a lampeggiare una volta al secondo. Se scolleghi il cavo USB e alimenti la scheda con un power bank o un alimentatore da 7–12 V, il programma continua a funzionare; le opzioni di alimentazione le spieghiamo in alimentare Arduino a batteria.

Come diventano i blocchi codice Arduino C?

In modalità caricamento fai clic sul pulsante del codice Arduino C sul bordo destro (l'icona con le parentesi angolari) e mBlock mostra in un pannello il codice che corrisponde ai tuoi blocchi. Ogni modifica ai blocchi aggiorna subito il codice; è il modo più semplice per imparare quale blocco produce quale riga. Se al programma Blink qui sopra aggiungi una variabile chiamata sayac (contatore) e la aumenti di 1 a ogni giro, il codice generato è più o meno questo. Le righe di commento le abbiamo aggiunte noi; spazi e posizione di alcune righe, come pinMode, possono cambiare un po' a seconda della versione.

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}

In questo codice ci sono quattro cose da notare. Primo, il blocco forever non diventa la funzione loop() di Arduino, ma un ciclo infinito while(1) dentro setup(); loop() si limita a chiamare la funzione _loop(). Secondo, il blocco wait usa una funzione _delay() al posto di delay(); mentre aspetta continua a chiamare _loop(), così i compiti in background di alcune estensioni non restano bloccati. Terzo, ogni variabile creata in mBlock viene dichiarata come float (numero decimale); sull'Uno ciascuna occupa 4 byte di RAM e può causare piccoli errori di arrotondamento nei confronti di uguaglianza. Per esempio, una variabile che aumenti a passi di 0,1 potrebbe non valere esattamente 1 dopo dieci passi, quindi un confronto "maggiore di" o "minore di" è più sicuro di "uguale a". Quarto, le librerie Wire e SoftwareSerial all'inizio vengono di solito incluse anche se non le usi; il programma funziona lo stesso, ma può occupare un po' più spazio di una versione scritta a mano.

Attività di esempio per le lezioni di robotica e coding

Le nove attività qui sotto sono ordinate dalla più facile alla più difficile per lezioni da 40 minuti, e funzionano tutte con l'unico montaggio descritto sopra. Iniziare ogni attività in modalità live è un buon metodo: gli studenti cliccano un blocco, vedono subito il risultato, seguono i valori dei sensori sullo stage e trovano da soli i propri errori. Quando il programma funziona come previsto, spostare gli stessi blocchi in modalità caricamento e scriverli in modo permanente sulla scheda insegna l'idea di "un dispositivo che funziona senza computer". I concetti di programmazione dietro queste attività li trovi anche in codice testuale nell'articolo basi della programmazione Arduino.

Le conversioni numeriche sono la parte più istruttiva delle lezioni. Il potenziometro dà valori da 0 a 1023, mentre il PWM si aspetta da 0 a 255; per questo nell'attività 5 dividi la lettura per 4 (1023 ÷ 4 ≈ 255). Per trasformare lo stesso valore in un angolo per il servo costruisci valore × 180 ÷ 1023 con i blocchi operatori. Nell'attività 9 dai all'Arduino, in modalità live, lo script "when green flag clicked, forever, set [pot] to (read analog pin A1)"; sullo sprite usi la stessa variabile in un blocco set x to (pot × 480 ÷ 1023 − 240) per distribuire la racchetta su tutta la larghezza dello stage, da −240 a 240. Se creando la variabile non spunti l'opzione "per tutti gli sprite", dispositivo e sprite non vedono la stessa variabile. Per il sensore di parcheggio apri l'Extension Center con il pulsante + extension (estensione) in fondo alla tavolozza e aggiungi un'estensione per il sensore a ultrasuoni; la maggior parte di queste estensioni è creata da sviluppatori della community, quindi nomi dei blocchi e pin supportati cambiano da un'estensione all'altra. Come funziona il sensore lo trovi nell'articolo sul sensore di distanza HC-SR04, le frequenze delle note in quello sul buzzer.

Passare all'Arduino IDE: dai blocchi al codice vero

A un certo punto i blocchi non bastano più: con programmi più lunghi l'area degli script diventa confusa, ti serve una libreria per un sensore che nell'Extension Center non c'è, oppure vuoi gestire più compiti insieme senza delay. È il momento dell'installazione dell'Arduino IDE e del passaggio al codice testuale; aggiungere librerie per nuovi sensori diventa una cosa che fai tu. Il modo migliore per rendere il passaggio graduale è riscrivere nell'Arduino IDE un progetto fatto in mBlock: così vedi due versioni della stessa logica una accanto all'altra.

1. In mBlock seleziona e copia il codice nel pannello Arduino C; apri un nuovo sketch nell'Arduino IDE e incollalo.
2. Nel menu Strumenti scegli la scheda (Arduino Uno) e la porta, poi fai clic prima su Verifica e poi su Carica. Il codice dovrebbe funzionare esattamente come in mBlock.
3. Poi semplifica il codice: raccogli le righe pinMode in setup(), sposta il contenuto del ciclo while(1) in loop() e usa delay() o millis() al posto di _delay().
4. Trasforma le variabili float in int o bool a seconda del caso e dai nomi chiari ai numeri dei pin con const int.
5. Stampa le variabili nel Monitor seriale per seguire cosa fa il programma; è l'equivalente, nel codice testuale, del monitoraggio live di mBlock.

Qui sotto c'è il programma che unisce le attività 3 e 4, cioè una luce notturna automatica che accendi e spegni con un pulsante, scritto per l'Arduino IDE. I numeri dei pin corrispondono alla tabella dei collegamenti qui sopra.

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}

Guarda le differenze rispetto alla versione mBlock: setup() viene eseguita una sola volta e prepara i pin, mentre loop() si ripete da sola, quindi while(1) non serve. Il pulsante viene confrontato con il suo stato precedente e conta solo nel momento in cui lo premi; altrimenti, finché tieni il dito sopra, il sistema si accenderebbe e spegnerebbe centinaia di volte al secondo. La funzione map() scala il valore della LDR tra 255 e 40, così il LED si illumina di più man mano che l'ambiente si fa buio. La stampa sul Monitor seriale avviene ogni mezzo secondo con millis() invece di delay(), così il programma non perde una pressione del pulsante mentre aspetta. I dettagli di questa tecnica sono in millis o delay, e la stampa dei dati nell'articolo sul Monitor seriale di Arduino.

Lo stesso programma su ESP32 e Raspberry Pi Pico

Nella libreria dei dispositivi di mBlock ci sono le schede Makeblock basate su ESP32, come CyberPi e HaloCode, ma non esiste un dispositivo ufficiale per una normale scheda di sviluppo ESP32 né per la Raspberry Pi Pico; le estensioni della community che compaiono ogni tanto, poi, cambiano da una versione all'altra. La buona notizia è che la logica imparata con i blocchi non cambia da una scheda all'altra. Programmando l'ESP32 con l'Arduino IDE usi quasi lo stesso codice; cambiano solo i numeri dei pin, la tensione di lavoro di 3,3 V e la scala a 12 bit dell'ADC, da 0 a 4095. Per questo la soglia di buio passa da 400 a circa 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}

Sulla Raspberry Pi Pico la strada più comune è MicroPython. Il programma qui sotto, da eseguire nell'editor Thonny, fa la stessa cosa: read_u16() restituisce il valore dell'ADC da 0 a 65535 e duty_u16() si aspetta il duty cycle del PWM sulla stessa scala. Perché Python sia un buon secondo passo dopo la programmazione a blocchi lo spieghiamo nell'articolo sulle basi di 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")

Aprire gli stessi progetti a blocchi sul telefono

Se vuoi continuare con la logica a blocchi costruita in mBlock anche lontano dal computer, dai un'occhiata all'app BlueGrays. Il codice di oltre 100 progetti Arduino, ESP32 e Raspberry Pi Pico dell'app è disponibile anche con i nostri blocchi basati su Blockly. Attiva Mostra a blocchi in un progetto e al posto del codice compare lo stesso programma a blocchi; la scheda Capire i blocchi spiega poi passo passo cosa fa ogni blocco. Le attività LED, semaforo, LED con pulsante, luce notturna con LDR, buzzer, sensore di parcheggio e servo con potenziometro di questa guida sono tutte lì, a blocchi e in codice Arduino C, e passi dall'uno all'altro con un tocco. Confrontare la sequenza che hai costruito in mBlock con i blocchi dell'app è un modo semplice per vedere come la stessa logica si costruisce in due strumenti diversi.

Anche per ESP32 e Pico, che come detto sopra non hanno un dispositivo ufficiale in mBlock, l'app ha progetti a blocchi: guarda prima la versione a blocchi e poi passa al codice Arduino C o MicroPython dello stesso progetto. Nella Guida al codice dell'app gli esempi dei comandi di base come digitalWrite, if/else e i cicli sono mostrati anche a blocchi. Se vuoi consolidare ciò che hai imparato, Domande del giorno ti propone 5 domande al giorno su livelli da A1 a C2, con una classifica settimanale e badge.

Problemi di connessione frequenti e soluzioni

Un modo rapido per capire se il problema dipende da mBlock o dalla scheda è provare a caricare l'esempio Blink sulla stessa scheda con l'Arduino IDE. Se anche l'Arduino IDE mostra un errore come avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00, la scheda e il computer non riescono a comunicare: il problema sta nella porta, nel cavo, nel tipo di scheda o nel bootloader. Analizziamo tutte le cause di questo errore nella guida Arduino non carica lo sketch; per saperne di più sul chip CH340 e sui suoi driver, leggi l'articolo sul convertitore USB-TTL. Se la scheda si riavvia da sola con un servo collegato, ti aiuteranno i consigli sull'alimentazione in Arduino si resetta da solo.

Idee di progetti con mBlock

• Semaforo con pulsante pedonale: premendo il pulsante il semaforo delle auto diventa rosso e si accende il verde per i pedoni; per circuito e codice guarda l'articolo sul semaforo con Arduino.
• Sensore di parcheggio: un bip che accelera e più LED accesi man mano che l'HC-SR04 misura una distanza minore.
• Robot che evita gli ostacoli: un'auto con due motori e un sensore di distanza che vede l'ostacolo davanti e cambia direzione; i dettagli sono nella guida al robot evita ostacoli.
• Robot segui linea: un robot da gara che segue un nastro nero con sensori a infrarossi (robot segui linea).
• Controller per lo stage: un gioco in modalità live in cui un potenziometro o un joystick guida un'astronave sullo stage.
• Irrigazione automatica delle piante: un sistema che accende una piccola pompa quando un sensore di umidità del terreno rileva terra secca.
• Radar con servo: un progetto che scansiona l'ambiente con un sensore di distanza montato su un servo e disegna uno schermo radar sullo stage (radar con Arduino).
• Auto robot: porta la logica di motori e sensori imparata in mBlock nel progetto costruire un'auto robot con Arduino.

mBlock è il modo più dolce per programmare un vero Arduino con la comodità dei blocchi e per passare al codice testuale quando sei pronto. Se non hai ancora una scheda, puoi provare le stesse attività nel browser con la simulazione Arduino su Tinkercad. Nell'app BlueGrays trovi schemi di collegamento passo passo e codice per i progetti LED, semaforo, LED con pulsante, luce notturna con LDR, buzzer, sensore di parcheggio HC-SR04 e servo con potenziometro, e puoi aprire gli stessi progetti anche a blocchi, così confronti con un tocco la versione a blocchi e quella in codice testuale di ogni attività costruita in mBlock.