Simulatore Wokwi: guida per ESP32, Arduino e Pico online
Simulatore Wokwi per ESP32, Arduino e Pico: cablaggio con diagram.json, Wi-Fi, MicroPython, analizzatore logico, estensione VS Code e differenze con Tinkercad.
Il simulatore Wokwi è un simulatore di elettronica gratuito che ti permette di eseguire progetti con ESP32, Arduino e Raspberry Pi Pico nel browser senza comprare nemmeno un componente. Scrivi il codice, metti LED, pulsanti, display e sensori accanto alla scheda virtuale e premi il pulsante verde di avvio: il codice viene compilato, il LED si accende, sull'OLED compare il testo e il Monitor seriale inizia a scorrere. La differenza principale rispetto a Tinkercad è il supporto per ESP32 e Pico; puoi persino portare l'ESP32 su Internet reale tramite una rete Wi-Fi virtuale ed eseguire MicroPython sul Pico.
In questa guida partirai aprendo il tuo primo progetto su wokwi.com, poi imparerai a collegare i componenti con il mouse e con il file diagram.json, aggiungere librerie, provare il Wi-Fi e l'ora da Internet con un ESP32, eseguire MicroPython sul Pico, misurare un segnale PWM con l'analizzatore logico e usare la stessa simulazione dentro VS Code. Alla fine vedrai quali sensori sono supportati, dove la simulazione si discosta da un circuito reale e come condividere il progetto.

Che cos'è Wokwi e come funziona?
Wokwi compila il tuo codice nel cloud con compilatori veri e passa il codice macchina ottenuto a un emulatore di processore che gira nel tuo browser. In una simulazione di Arduino Uno, quindi, le istruzioni dell'ATmega328P vengono eseguite una per una, e lo stesso approccio vale per ESP32 e RP2040. Per questo funzioni hardware come millis(), interrupt, timer, PWM, I2C e SPI si comportano come sulla scheda reale e le librerie vere funzionano senza modifiche. Wokwi non calcola correnti e tensioni del circuito; modella i livelli digitali dei pin e i valori inviati agli ingressi analogici. Questa impostazione lo rende uno strumento potente per provare software embedded, più che per imparare le basi dell'elettronica.
| Caratteristica | Wokwi |
|---|---|
| Dove funziona | Browser (wokwi.com) ed estensione VS Code |
| Schede | Arduino Uno, Nano, Mega; ESP32, ESP32-S3, ESP32-C3; Raspberry Pi Pico e Pico W |
| Linguaggi | Arduino C++, MicroPython, CircuitPython (Pico), ESP-IDF |
| Librerie | La maggior parte di quelle del Gestore librerie di Arduino (libraries.txt) |
| Rete | Wi-Fi virtuale per ESP32 e Pico W: Wokwi-GUEST |
| Strumento di misura | Analizzatore logico a 8 canali; nessuna misura elettrica |
| Account | Non serve per provare, accedi per salvare il progetto |
| Prezzo | L'uso base è gratuito; le funzioni extra sono in un piano a pagamento |
Quali schede ci sono in Wokwi?
Ogni componente di Wokwi ha un nome di tipo, che vedrai nel file diagram.json. La tabella mostra gli equivalenti Wokwi delle tre piattaforme su cui si concentra questo blog. Nei progetti più vecchi potresti vedere anche wokwi-esp32-devkit-v1 per l'ESP32; entrambi simulano lo stesso chip ESP32, cambia solo la disposizione dei pin della scheda.
| Scheda | Nome di tipo Wokwi | Linguaggi | Nota |
|---|---|---|---|
| Arduino Uno | wokwi-arduino-uno | Arduino C++ | ATmega328P, logica a 5 V, simulazione più veloce |
| Arduino Nano | wokwi-arduino-nano | Arduino C++ | Stesso chip dell'Uno, scheda più piccola |
| Arduino Mega | wokwi-arduino-mega | Arduino C++ | 8 KB di SRAM, progetti con molti pin |
| ESP32 DevKit | board-esp32-devkit-c-v4 | Arduino C++, MicroPython, ESP-IDF | Wi-Fi sì, Bluetooth no |
| ESP32-S3 / ESP32-C3 | board-esp32-s3-devkitc-1 / board-esp32-c3-devkitm-1 | Arduino C++, MicroPython, ESP-IDF | Famiglie ESP32 più recenti |
| Raspberry Pi Pico | wokwi-pi-pico | MicroPython, CircuitPython, Arduino C++ | RP2040, logica a 3,3 V |
| Raspberry Pi Pico W | board-pi-pico-w | MicroPython, Arduino C++ | Con Wi-Fi |
Il tuo primo progetto Wokwi nel browser, passo passo
- Apri wokwi.com nel browser. La home page ha le sezioni Arduino, ESP32 e Raspberry Pi Pico; scegline una per vedere modelli pronti e progetti di esempio.
- Per partire da zero, scegli il modello Arduino Uno nella sezione Arduino. Lo schermo si divide in due: a sinistra l'editor del codice (sketch.ino), a destra l'area del diagramma dove si disegna il circuito.
- Premi il pulsante blu + sopra l'area di destra e scrivi LED nella ricerca. Il componente scelto compare vicino alla scheda; trascinalo con il mouse dove vuoi.
- Aggiungi allo stesso modo un Resistor e un Pushbutton. Facendo clic su un componente si apre un piccolo pannello per cambiarne colore o valore; imposta il resistore a 220 Ω.
- Per tracciare un filo, fai clic sull'estremità di un pin e poi sul pin di destinazione. Fai clic su un punto vuoto intermedio per piegare il percorso. Facendo clic su un filo puoi cambiarne il colore o eliminarlo con il tasto Canc.
- Scrivi il codice a sinistra o incolla l'esempio qui sotto, poi premi il pulsante verde di avvio. La prima compilazione richiede qualche secondo; poi parte la simulazione e, se usi Serial.begin, il Monitor seriale si apre in basso.
- Mentre la simulazione è in corso, fai clic sul pulsante con il mouse. Per fermarla premi il pulsante quadrato. Per conservare il progetto premi Save; la prima volta ti verrà chiesto di accedere e il progetto riceverà un link permanente.
Primo circuito: accendere e spegnere un LED con un pulsante
Il classico primo esperimento, un pulsante e un LED, si monta con la stessa logica su tutte e tre le schede. La gamba lunga del LED (anodo, A in Wokwi) va al pin di uscita attraverso il resistore, quella corta (catodo, C) va a GND. Un lato del pulsante va al pin di ingresso e l'altro a GND; il codice attiva la resistenza di pull-up interna. Per calcolare il resistore del LED nel tuo circuito puoi usare il calcolatore della resistenza per LED.
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Anodo del LED (A), tramite resistore da 220 Ω | D13 | GPIO 18 | GP14 |
| Catodo del LED (C) | GND | GND | GND |
| Pulsante, piedino 1 | D2 | GPIO 4 | GP2 |
| Pulsante, piedino 2 | GND | GND | GND |
| Livello logico | 5 V | 3,3 V | 3,3 V |
1// Wokwi ilk proje: buton ile LED aç/kapat / Wokwi first project: toggle an LED with a button
2const int LED_PIN = 13; // ESP32'de 18 / 18 on ESP32
3const int BUTON_PIN = 2; // ESP32'de 4, diğer uç GND / 4 on ESP32, other leg to GND
4
5bool ledDurum = false; // LED durumu / LED state
6bool oncekiOkuma = HIGH; // önceki buton okuması / previous button reading
7unsigned long sonDegisim = 0; // son kabul edilen değişim / last accepted change
8
9void setup() {
10 pinMode(LED_PIN, OUTPUT);
11 pinMode(BUTON_PIN, INPUT_PULLUP); // dahili pull-up: basılınca LOW / internal pull-up: LOW when pressed
12 Serial.begin(115200);
13 Serial.println("Wokwi hazir / ready");
14}
15
16void loop() {
17 bool okuma = digitalRead(BUTON_PIN);
18 if (okuma != oncekiOkuma && millis() - sonDegisim > 50) { // 50 ms debounce
19 sonDegisim = millis();
20 oncekiOkuma = okuma;
21 if (okuma == LOW) { // basıldı / pressed
22 ledDurum = !ledDurum;
23 digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
24 Serial.print("LED: ");
25 Serial.println(ledDurum ? "ACIK / ON" : "KAPALI / OFF");
26 }
27 }
28}Il pulsante di Wokwi ha i rimbalzi come uno vero: con una sola pressione il contatto si apre e si chiude per qualche millisecondo. Per questo il codice aspetta 50 ms; se lo togli, vedrai a volte il LED cambiare stato due volte. È un bel dettaglio, perché ciò che impari in simulazione serve anche nel circuito reale. La logica dei tempi è spiegata in dettaglio nell'articolo millis e delay.
diagram.json: collegare i componenti con un file
Tutto ciò che disegni con il mouse viene in realtà scritto nel file diagram.json del progetto. Puoi aprirlo dalle schede sopra l'editor, modificarlo a mano o copiarlo in un altro progetto. Il file ha tre sezioni importanti: parts (i componenti con tipo, posizione e impostazioni), connections (i fili) e la sezione facoltativa dependencies. Ecco il diagram.json del circuito con Uno visto sopra:
1{
2 "version": 1,
3 "author": "BlueGrays",
4 "editor": "wokwi",
5 "parts": [
6 { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} },
7 { "type": "wokwi-led", "id": "led1", "top": -96, "left": 172, "attrs": { "color": "red" } },
8 { "type": "wokwi-resistor", "id": "r1", "top": -24, "left": 120, "rotate": 90, "attrs": { "value": "220" } },
9 { "type": "wokwi-pushbutton", "id": "btn1", "top": -110, "left": 260, "attrs": { "color": "green", "bounce": "1" } }
10 ],
11 "connections": [
12 [ "uno:13", "r1:1", "green", [] ],
13 [ "r1:2", "led1:A", "green", [] ],
14 [ "led1:C", "uno:GND.1", "black", [] ],
15 [ "uno:2", "btn1:1.l", "blue", [] ],
16 [ "btn1:2.l", "uno:GND.2", "black", [] ]
17 ],
18 "dependencies": {}
19}| Campo | A cosa serve? | Esempio |
|---|---|---|
| type | Tipo del componente | wokwi-led, wokwi-dht22, board-ssd1306 |
| id | Nome del componente; i fili usano questo nome | led1, uno, esp |
| top / left / rotate | Posizione sullo schermo (pixel) e angolo di rotazione | "rotate": 90 |
| attrs | Impostazioni specifiche del componente | "color": "red", "value": "220" |
| connections | Ogni filo: [pin iniziale, pin finale, colore, percorso] | ["uno:13", "r1:1", "green", []] |
| Formato del nome dei pin | id-componente:nome-pin | uno:GND.1, esp:18, pico:GP14, btn1:1.l |
Il modo più semplice per imparare i nomi dei pin è passare con il mouse sopra un pin nel diagramma; Wokwi ne mostra il nome in una piccola etichetta. I quattro piedini del pulsante si chiamano 1.l, 2.l, 1.r, 2.r: quelli con lo stesso numero sono collegati internamente e la pressione unisce 1 e 2. Imposta l'attributo bounce del pulsante su "0" per eliminare i rimbalzi; dai all'attributo key un valore come "1" e potrai premerlo anche dalla tastiera. Nei circuiti grandi, modificare diagram.json a mano è molto più veloce che disegnare decine di fili uno per uno.
Aggiungere librerie: libraries.txt
Per installare una libreria Arduino in Wokwi, apri la scheda Library Manager sopra l'editor, premi + e cerca il nome della libreria. La libreria scelta viene aggiunta come riga nel file libraries.txt del progetto e installata automaticamente nel cloud durante la compilazione. Puoi anche scrivere il file a mano; ogni riga contiene una libreria, con il nome che ha nel Gestore librerie di Arduino:
1# Wokwi Library List
2Adafruit SSD1306
3Adafruit GFX Library
4DHT sensor library
5Adafruit NeoPixelInteragire con i sensori: cambiare i valori durante la simulazione
La cosa più didattica di Wokwi è che puoi regolare i valori dei sensori con il mouse. Durante la simulazione, fai clic sul DHT22 per aprire i cursori di temperatura e umidità; sull'HC-SR04 scegli una distanza tra 2 e 400 cm. Il sensore PIR ha un pulsante che simula il movimento, il potenziometro una manopola da ruotare e il modulo LDR un cursore per l'intensità luminosa (lux). Così verifichi in pochi secondi una condizione come "accendi la ventola quando la temperatura supera 30 °C" e controlli le soglie del codice senza avere il sensore reale.
Simulazione Wi-Fi con l'ESP32
In Wokwi l'ESP32 si collega a un access point virtuale chiamato Wokwi-GUEST. Questa rete non ha password e usa il canale 6; indicare il canale velocizza la connessione. La rete raggiunge Internet reale attraverso il gateway di Wokwi: puoi ottenere l'ora via NTP, inviare richieste HTTP a un server o pubblicare dati su un broker MQTT. Il codice qui sotto collega l'ESP32, stampa il suo indirizzo IP e prende da Internet l'ora di Istanbul.
1#include <WiFi.h>
2#include <time.h>
3
4void setup() {
5 Serial.begin(115200);
6 WiFi.begin("Wokwi-GUEST", "", 6); // Wokwi sanal ağı: şifresiz, kanal 6 / Wokwi virtual network: open, channel 6
7 Serial.print("Baglaniyor / Connecting");
8 while (WiFi.status() != WL_CONNECTED) {
9 delay(250);
10 Serial.print(".");
11 }
12 Serial.println();
13 Serial.print("IP: ");
14 Serial.println(WiFi.localIP());
15 configTime(3 * 3600, 0, "pool.ntp.org"); // UTC+3 İstanbul, yaz saati yok / UTC+3 Istanbul, no DST
16}
17
18void loop() {
19 struct tm zaman; // saat bilgisi / time info
20 if (getLocalTime(&zaman)) {
21 Serial.printf("%02d:%02d:%02d\n", zaman.tm_hour, zaman.tm_min, zaman.tm_sec);
22 } else {
23 Serial.println("Saat alinamadi / Time not ready");
24 }
25 delay(1000);
26}Quando usi questo codice su un ESP32 reale basta scrivere il nome della tua rete e la password; il parametro del canale si può togliere. Nell'uso gratuito l'ESP32 può collegarsi verso l'esterno, ma il browser del tuo computer non può raggiungere direttamente un web server che gira dentro l'ESP32. Per questo serve l'inoltro delle porte dell'estensione VS Code oppure il gateway privato del piano a pagamento. Per NTP e fusi orari vedi ora NTP con ESP32, e per i problemi di connessione su una scheda reale l'ESP32 non si connette al Wi-Fi.
Raspberry Pi Pico e supporto MicroPython

Quando scegli il modello MicroPython per il Pico nella home page, il progetto si apre con un file main.py. Premendo avvio si carica l'interprete MicroPython, main.py viene eseguito e vedi l'output di print nella console in basso. Al termine del programma la stessa console passa alla REPL, dove puoi scrivere comandi e provarli subito. Se ti servono moduli aggiuntivi come il driver SSD1306, crea un nuovo file dal menu dei file e incolla il contenuto del modulo. Per l'ESP32 vale lo stesso: scegli il modello MicroPython nella sezione ESP32.
1from machine import Pin, ADC
2import time
3
4led = Pin(14, Pin.OUT) # LED + 220 ohm direnç / LED + 220 ohm resistor
5buton = Pin(2, Pin.IN, Pin.PULL_UP) # diğer uç GND / other leg to GND
6pot = ADC(26) # potansiyometre orta ucu GP26 / pot wiper on GP26
7
8durum = False
9onceki = 1
10son = time.ticks_ms() # son pot yazdırma zamanı / last pot print time
11while True:
12 okuma = buton.value()
13 if okuma == 0 and onceki == 1: # yeni basış / new press
14 durum = not durum
15 led.value(durum)
16 print("LED:", "ACIK" if durum else "KAPALI")
17 time.sleep_ms(50) # debounce
18 onceki = okuma
19 if time.ticks_diff(time.ticks_ms(), son) >= 500:
20 son = time.ticks_ms()
21 gerilim = pot.read_u16() * 3.3 / 65535 # 16 bit okuma -> volt / 16-bit reading -> volts
22 print("Pot: {:.2f} V".format(gerilim))
23 time.sleep_ms(10)Nel codice il LED è su GP14, il pulsante su GP2 e il cursore del potenziometro su GP26 (ADC0); i piedini esterni del potenziometro vanno a 3V3 e GND. L'ADC del Pico è a 12 bit, ma read_u16() di MicroPython restituisce un valore scalato su 0–65535. Se sei alle prime armi con MicroPython, l'articolo basi di MicroPython spiega uno per uno i comandi di Pin, ADC, PWM e temporizzazione.
Vedere i segnali con l'analizzatore logico
Wokwi non ha un multimetro, ma ha uno strumento molto più potente: il Logic Analyzer. Lo aggiungi dalla lista dei componenti e registra 8 canali digitali (D0–D7). Collega i canali ai pin da misurare e il suo GND al GND della scheda. Quando fermi la simulazione, la registrazione viene scaricata come file .vcd; aprila con programmi gratuiti come PulseView o GTKWave per leggere frequenza e larghezza d'impulso e persino decodificare byte UART, I2C o SPI.
1// Mantık analizörü D0 -> Uno D9, D1 -> Uno D1 (TX), GND -> GND
2// Logic analyzer D0 -> Uno D9, D1 -> Uno D1 (TX), GND -> GND
3void setup() {
4 Serial.begin(9600);
5 analogWrite(9, 64); // %25 doluluk, yaklaşık 490 Hz / 25% duty, about 490 Hz
6}
7
8void loop() {
9 Serial.write('A'); // TX hattında çözülecek bayt / byte to decode on the TX line
10 delay(100);
11}Aprendo la registrazione, il canale D0 mostra un'onda quadra con un periodo di circa 2,04 ms (490 Hz); l'impulso resta alto per un quarto del periodo, circa 0,51 ms. Questo perché analogWrite(9, 64) corrisponde a un duty cycle di 64/255 ≈ 25%. Sull'Uno i pin 5 e 6 generano 980 Hz e gli altri pin PWM 490 Hz; puoi verificarlo tu stesso con l'analizzatore. Se aggiungi un decoder UART al canale D1 in PulseView, leggerai il byte 0x41 (A) ogni 100 ms. Per capire come funziona il PWM leggi Che cos'è il PWM?.
L'estensione Wokwi per VS Code
Nei progetti più grandi, se preferisci il tuo editor al browser, puoi installare l'estensione Wokwi Simulator in VS Code. L'estensione non compila; simula il file firmware che produci con PlatformIO, ESP-IDF o arduino-cli. Per uso personale si ottiene una licenza gratuita da rinnovare periodicamente. La configurazione richiede questi passi:
- In VS Code cerca Wokwi Simulator nella vista Estensioni e installala.
- Apri la palette dei comandi con F1, esegui Wokwi: Request a New License e conferma la licenza nella pagina che si apre nel browser.
- Aggiungi un file wokwi.toml e un file diagram.json nella radice della cartella del progetto. Puoi copiare diagram.json da un progetto disegnato nel browser.
- Compila il progetto come al solito (Build in PlatformIO). I percorsi in wokwi.toml devono puntare ai file .bin ed .elf generati.
- Premi F1 ed esegui Wokwi: Start Simulator. La simulazione si apre in una scheda di VS Code; quando modifichi il codice e ricompili, la simulazione riparte.
1# wokwi.toml (PlatformIO, esp32dev ortamı / environment)
2[wokwi]
3version = 1
4firmware = ".pio/build/esp32dev/firmware.bin"
5elf = ".pio/build/esp32dev/firmware.elf"
6
7# ESP32 web sunucusunu bilgisayardan açmak: http://localhost:8180
8# Open the ESP32 web server from your computer: http://localhost:8180
9[[net.forward]]
10from = "localhost:8180"
11to = "target:80"La sezione net.forward inoltra il web server sulla porta 80 dell'ESP32 alla porta 8180 del tuo computer. In questo modo puoi aprire nel tuo browser progetti come il web server e WebSocket con ESP32 senza programmare una scheda. L'estensione supporta anche il debug passo passo con GDB; aggiungi una riga gdbServerPort in wokwi.toml e collega il debugger di VS Code.
Differenze tra Wokwi e Tinkercad
Entrambi i simulatori sono gratuiti e girano nel browser, ma rispondono a domande diverse. Tinkercad calcola il circuito dal punto di vista elettrico: puoi misurare con un multimetro la corrente in un resistore o la tensione su un LED, e supporta la programmazione a blocchi. Wokwi emula il processore della scheda e offre ESP32, Pico, Wi-Fi, MicroPython e un ampio supporto di librerie. La strada più efficiente è imparare le basi dell'elettronica con Tinkercad e i progetti ESP32 e IoT con Wokwi. Per conoscere Tinkercad nel dettaglio, leggi la guida simulatore Tinkercad per Arduino.
| Caratteristica | Wokwi | Tinkercad Circuits |
|---|---|---|
| Schede | Uno, Nano, Mega, famiglia ESP32, Pico, Pico W | Arduino Uno R3, ATtiny, micro:bit |
| Calcolo elettrico | No; livelli digitali e un modello dei valori analogici | Sì; multimetro e oscilloscopio |
| Wi-Fi e Internet | Sì, con ESP32 e Pico W | No |
| MicroPython | Sì, su Pico ed ESP32 | No |
| Librerie | La maggior parte di quelle del Gestore librerie | Circa undici librerie integrate |
| Programmazione a blocchi | No | Sì |
| File del circuito | diagram.json, modificabile a mano | Solo editor visuale |
| Misura | Analizzatore logico (.vcd) | Multimetro, oscilloscopio |
| Desktop | Estensione VS Code | No |
Sensori e moduli supportati
| Gruppo | Disponibile in Wokwi | Assente o limitato |
|---|---|---|
| Luce e display | LED, LED RGB, striscia e anello NeoPixel, LCD 16x2 e 20x4 (anche I2C), OLED SSD1306, TFT ILI9341, matrice MAX7219, TM1637, display a 7 segmenti | E-paper e la maggior parte degli OLED a colori |
| Ingressi | Pulsante, interruttore, DIP switch, potenziometro, encoder rotativo (KY-040), joystick, tastierino a membrana, ricevitore IR e telecomando | Touch screen |
| Sensori | DHT22, DS18B20, HC-SR04, PIR, MPU6050, modulo LDR, modulo NTC, HX711 e cella di carico, gas MQ-2, fiamma, suono, inclinazione | DHT11 (usa il DHT22), sensori di colore e di impronte |
| Movimento | Servo, motore passo-passo, driver A4988, modulo relè, buzzer | Motore DC e driver come l'L298N |
| Comunicazione e memoria | RTC DS1307, scheda microSD, 74HC595, I2C, SPI, UART | RFID RC522, nRF24L01, HC-05, SIM800L, GPS |
| Circuiti analogici | Potenziometro e moduli sensore analogici | Vero calcolo analogico di transistor, amplificatori operazionali, condensatori |
Per un componente che non è in lista hai due strade. La prima è usare un componente dal comportamento simile; per esempio provi il codice del DHT11 con il DHT22. La seconda è la funzione Custom Chips: un piccolo programma scritto in C viene compilato in WebAssembly e aggiunto al circuito come un nuovo componente con i suoi pin. Così puoi modellare da solo un semplice sensore I2C o un modulo che comunica via UART.
Limiti della simulazione: differenze con un circuito reale
- Nessun calcolo elettrico: un LED collegato senza resistore resta acceso e 5 V su un pin dell'ESP32 non bruciano nulla. In un circuito reale entrambe le cose ti costano componenti. Calcola corrente e tensione da solo con la legge di Ohm.
- Velocità: l'indicatore nell'angolo dell'area del diagramma mostra a che percentuale del tempo reale gira la simulazione. I progetti ESP32 con Wi-Fi o con molti componenti possono andare più lenti del tempo reale; tienine conto nel codice che misura durate.
- Sensori ideali: i sensori virtuali non hanno rumore e non vanno calibrati. Un DHT22 reale sbaglia di ±0,5 °C e un HC-SR04 misura male sulle superfici morbide; scrivi comunque filtri e controlli degli errori.
- Niente alimentazione né batteria: consumo di corrente, cadute di tensione, riscaldamento del regolatore e brownout non compaiono nella simulazione.
- Niente Bluetooth: le funzioni BLE e Bluetooth classico dell'ESP32 non vengono simulate.
- Errori di cablaggio: i problemi reali come un jumper allentato, una fila sbagliata della breadboard o una saldatura fredda non esistono; un circuito che funziona in simulazione potrebbe non funzionare al primo colpo nella realtà.
Condividere il progetto e portarlo su una scheda reale
Ogni progetto salvato riceve un indirizzo permanente; con il pulsante Share copi il link e lo mandi a un amico, all'insegnante o in un forum. Chi apre il link avvia il progetto con un clic e può copiarlo nel proprio account per modificarlo. Per questo Wokwi è il modo più veloce di mostrare circuito e codice insieme quando chiedi aiuto perché "il mio codice non funziona". Dal menu accanto al pulsante Save puoi scaricare il progetto come file zip con sketch.ino, diagram.json e libraries.txt.
- Incolla il codice che funziona in simulazione in un nuovo sketch dell'Arduino IDE oppure apri sketch.ino dallo zip scaricato.
- Installa ogni libreria di libraries.txt dal Gestore librerie dell'Arduino IDE.
- Nel codice Wi-Fi sostituisci Wokwi-GUEST con il nome della tua rete e la password.
- Riporta i collegamenti di diagram.json in una tabella dei pin e monta il circuito sulla breadboard seguendo la tabella. Non dimenticare i resistori di cui Wokwi non aveva bisogno (resistore del LED, pull-up I2C).
- Seleziona scheda e porta e carica. Se qualcosa va storto, segui i passi della guida Arduino non carica lo sketch.
Idee di progetto da provare in Wokwi
- Stazione meteo con OLED: mostra temperatura e umidità con ESP32, DHT22 e SSD1306; cambia i valori con i cursori. Per il codice del display leggi display OLED SSD1306.
- Sensore di parcheggio: cambia il ritmo dei bip del buzzer in base alla distanza dell'HC-SR04 e prova tutte le soglie con il cursore della distanza. Dettagli in sensore di distanza HC-SR04.
- Animazioni NeoPixel: prova transizioni di colore su un anello o una matrice WS2812B e progetta gli effetti prima di pensare all'alimentatore di una striscia reale. Vedi LED WS2812B NeoPixel.
- Domotica con MQTT: invia la temperatura dall'ESP32 virtuale a un broker MQTT. Segui la guida ESP32 con MQTT e Home Assistant per la configurazione.
- Serratura con tastierino: costruisci una serratura con tastierino a membrana, servo e LCD e osserva i tentativi con codice errato nel Monitor seriale.
- Esperimenti con gli interrupt: leggi il pulsante con attachInterrupt e guarda con l'analizzatore logico come i rimbalzi aumentano il numero di interrupt. Vedi interrupt su Arduino.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| L'ESP32 non si connette al Wi-Fi e i puntini continuano | Nome della rete sbagliato o password inserita | Usa WiFi.begin("Wokwi-GUEST", "", 6); il nome distingue maiuscole e minuscole |
| Errore No such file or directory | La libreria non è in libraries.txt | Aggiungi la libreria dalla scheda Library Manager |
| Il LED non si accende | LED al contrario (A e C scambiati) o filo di GND mancante | Collega la gamba lunga A al resistore e C a GND |
| Una pressione incrementa il contatore di due | Vengono simulati i rimbalzi del pulsante | Aggiungi il debounce al codice o usa "bounce": "0" nelle prove |
| La simulazione è molto lenta | Stampa continua su Serial senza pause nel loop | Metti un breve delay nel loop e riduci l'output inutile |
| ImportError: no module named in MicroPython | Il file del modulo non è nel progetto | Crea un nuovo file dal menu e incolla il modulo |
| Il web server dell'ESP32 non si apre nel browser | Il gateway gratuito consente solo connessioni dall'interno verso l'esterno | Usa net.forward nell'estensione VS Code |
| Il progetto è sparito | Hai lavorato senza accedere | Salva con Save; sui progetti altrui scegli Save a copy |
Wokwi è il modo più pratico per provare un'idea prima di comprare i componenti, condividere un errore insieme al circuito e provare il codice Wi-Fi senza rischi, soprattutto con ESP32 e Pico. La maggior parte dei progetti dell'app BlueGrays include un video di simulazione registrato mentre il circuito gira in Wokwi; puoi vedere quando si accende il LED e come si aggiorna il display prima di iniziare il montaggio, e poi realizzare lo stesso progetto sulla tua scheda reale con lo schema e il codice passo passo.
Domande frequenti
Wokwi è gratis?
Sì, la versione browser di Wokwi è gratuita per l'uso base: puoi creare, salvare e condividere progetti e portare un ESP32 su Internet tramite il Wi-Fi virtuale. Funzioni extra come il gateway privato e compilazioni più veloci fanno parte di un piano a pagamento. Anche l'estensione VS Code funziona con una licenza gratuita per uso personale.
Come collego un ESP32 al Wi-Fi in Wokwi?
Nel codice dell'ESP32 usa Wokwi-GUEST come nome della rete e una stringa vuota come password: WiFi.begin("Wokwi-GUEST", "", 6). L'ultimo parametro, il canale 6, velocizza la connessione. Una volta connesso, l'ESP32 raggiunge Internet reale tramite NTP, HTTP e MQTT.
Meglio Wokwi o Tinkercad?
Tinkercad è più adatto per imparare le basi dell'elettronica, misurare corrente e tensione con il multimetro e programmare a blocchi. Wokwi si distingue nei progetti che richiedono ESP32, Raspberry Pi Pico, Wi-Fi, MicroPython e molte librerie. Molti studenti usano entrambi.
Come si aggiunge una libreria in Wokwi?
Apri la scheda Library Manager sopra l'editor, premi +, cerca la libreria e selezionala. Viene aggiunta al file libraries.txt e installata automaticamente durante la compilazione. Puoi anche scrivere a mano nel file il nome della libreria, esattamente come appare nel Gestore librerie di Arduino.
In Wokwi c'è il DHT11?
La lista dei componenti di Wokwi comprende il DHT22, ma non il DHT11. Per provare un codice scritto per il DHT11, metti nel circuito un DHT22 e imposta il tipo di sensore della libreria su DHT22. Sulla scheda reale basta rimettere il tipo DHT11.
Il codice di Wokwi funziona su una scheda reale?
Sì. Poiché Wokwi esegue normale codice Arduino e MicroPython, puoi caricare lo stesso codice su una scheda reale con l'Arduino IDE o Thonny. Devi solo installare le librerie, cambiare nome e password del Wi-Fi e aggiungere al circuito i resistori di cui Wokwi non aveva bisogno.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Controllo LED ESP32 con pulsante (Push)
Il LED si accende quando il pulsante viene premuto e si spegne quando viene rilasciato. Mostra come vengono utilizzati il pin di ingresso digitale dell'ESP32 e la resistenza di pull-up interna. Grazie alla modalità INPUT_PULLUP, non è necessaria alcuna resistenza esterna.

Controllo LED ESP32 con pulsante (Toggle)
Ogni volta che si preme il pulsante, lo stato del LED cambia: se è acceso si spegne, se è spento si accende. Classico schema toggle. Con il debounce puliamo il rumore meccanico del pulsante per garantire una singola commutazione con una sola pressione.

Lettura dell'intensità luminosa con il modulo LDR ESP32
Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
Il passo successivo al LED integrato del Pico: collegare un LED esterno sulla breadboard e controllarlo dal pin GP14. Impari a usare qualsiasi pin GPIO del Pico come uscita, la polarità del LED (gamba lunga = anodo/+, gamba corta = catodo/–) e perché una resistenza di limitazione della corrente (220Ω) è indispensabile. Senza di essa nel LED passa troppa corrente e può bruciarsi.

Raspberry Pi Pico LED Controllato da Pulsante (Push)
Primo progetto di input con Pico — lettura pulsante! LED si accende mentre il pulsante è premuto. Impara Pin.IN, Pin.PULL_UP e button.value(). GP14 LED, GP2 pulsante con PULL_UP interno. Premuto = 0, rilasciato = 1 — standard.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

