Guide · 14 min di lettura

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.

Scheda di sviluppo ESP32
Il punto di forza di Wokwi è il supporto all'ESP32: Wi-Fi, PWM, ADC, I2C e SPI vengono simulati come sulla scheda reale.

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.

CaratteristicaWokwi
Dove funzionaBrowser (wokwi.com) ed estensione VS Code
SchedeArduino Uno, Nano, Mega; ESP32, ESP32-S3, ESP32-C3; Raspberry Pi Pico e Pico W
LinguaggiArduino C++, MicroPython, CircuitPython (Pico), ESP-IDF
LibrerieLa maggior parte di quelle del Gestore librerie di Arduino (libraries.txt)
ReteWi-Fi virtuale per ESP32 e Pico W: Wokwi-GUEST
Strumento di misuraAnalizzatore logico a 8 canali; nessuna misura elettrica
AccountNon serve per provare, accedi per salvare il progetto
PrezzoL'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.

SchedaNome di tipo WokwiLinguaggiNota
Arduino Unowokwi-arduino-unoArduino C++ATmega328P, logica a 5 V, simulazione più veloce
Arduino Nanowokwi-arduino-nanoArduino C++Stesso chip dell'Uno, scheda più piccola
Arduino Megawokwi-arduino-megaArduino C++8 KB di SRAM, progetti con molti pin
ESP32 DevKitboard-esp32-devkit-c-v4Arduino C++, MicroPython, ESP-IDFWi-Fi sì, Bluetooth no
ESP32-S3 / ESP32-C3board-esp32-s3-devkitc-1 / board-esp32-c3-devkitm-1Arduino C++, MicroPython, ESP-IDFFamiglie ESP32 più recenti
Raspberry Pi Picowokwi-pi-picoMicroPython, CircuitPython, Arduino C++RP2040, logica a 3,3 V
Raspberry Pi Pico Wboard-pi-pico-wMicroPython, Arduino C++Con Wi-Fi

Il tuo primo progetto Wokwi nel browser, passo passo

  1. 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.
  2. 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.
  3. 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.
  4. 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 Ω.
  5. 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.
  6. 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.
  7. 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.
Un progetto creato senza accedere non viene salvato; sparisce quando chiudi la scheda del browser. Se apri il progetto di un altro, le tue modifiche non vengono scritte nel suo progetto; usa Save a copy per copiarlo nel tuo account.

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.

CollegamentoArduino UnoESP32Raspberry Pi Pico
Anodo del LED (A), tramite resistore da 220 ΩD13GPIO 18GP14
Catodo del LED (C)GNDGNDGND
Pulsante, piedino 1D2GPIO 4GP2
Pulsante, piedino 2GNDGNDGND
Livello logico5 V3,3 V3,3 V
C++ (Arduino IDE)
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:

Codice
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}
CampoA cosa serve?Esempio
typeTipo del componentewokwi-led, wokwi-dht22, board-ssd1306
idNome del componente; i fili usano questo nomeled1, uno, esp
top / left / rotatePosizione sullo schermo (pixel) e angolo di rotazione"rotate": 90
attrsImpostazioni specifiche del componente"color": "red", "value": "220"
connectionsOgni filo: [pin iniziale, pin finale, colore, percorso]["uno:13", "r1:1", "green", []]
Formato del nome dei pinid-componente:nome-pinuno: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:

Codice
1# Wokwi Library List
2Adafruit SSD1306
3Adafruit GFX Library
4DHT sensor library
5Adafruit NeoPixel
Se la compilazione mostra l'errore No such file or directory, la libreria non è in libraries.txt oppure il nome è scritto male. Per installare la libreria nel vero Arduino IDE, leggi l'articolo come installare una libreria Arduino.

Interagire 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.

C++ (Arduino IDE)
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.

Wokwi simula il Wi-Fi dell'ESP32, ma Bluetooth e BLE non vengono simulati. Il codice con BLE o Bluetooth classico si compila, ma non compare alcun dispositivo a cui collegarti dal telefono; queste parti vanno provate su una scheda reale.

Raspberry Pi Pico e supporto MicroPython

Scheda Raspberry Pi Pico
In Wokwi puoi far girare il Pico con MicroPython e provare il codice nel browser prima di passare a Thonny.

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.

MicroPython
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.

C++ (Arduino IDE)
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:

  1. In VS Code cerca Wokwi Simulator nella vista Estensioni e installala.
  2. Apri la palette dei comandi con F1, esegui Wokwi: Request a New License e conferma la licenza nella pagina che si apre nel browser.
  3. 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.
  4. Compila il progetto come al solito (Build in PlatformIO). I percorsi in wokwi.toml devono puntare ai file .bin ed .elf generati.
  5. 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.
Codice
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.

CaratteristicaWokwiTinkercad Circuits
SchedeUno, Nano, Mega, famiglia ESP32, Pico, Pico WArduino Uno R3, ATtiny, micro:bit
Calcolo elettricoNo; livelli digitali e un modello dei valori analogiciSì; multimetro e oscilloscopio
Wi-Fi e InternetSì, con ESP32 e Pico WNo
MicroPythonSì, su Pico ed ESP32No
LibrerieLa maggior parte di quelle del Gestore librerieCirca undici librerie integrate
Programmazione a blocchiNoSì
File del circuitodiagram.json, modificabile a manoSolo editor visuale
MisuraAnalizzatore logico (.vcd)Multimetro, oscilloscopio
DesktopEstensione VS CodeNo

Sensori e moduli supportati

GruppoDisponibile in WokwiAssente o limitato
Luce e displayLED, LED RGB, striscia e anello NeoPixel, LCD 16x2 e 20x4 (anche I2C), OLED SSD1306, TFT ILI9341, matrice MAX7219, TM1637, display a 7 segmentiE-paper e la maggior parte degli OLED a colori
IngressiPulsante, interruttore, DIP switch, potenziometro, encoder rotativo (KY-040), joystick, tastierino a membrana, ricevitore IR e telecomandoTouch screen
SensoriDHT22, DS18B20, HC-SR04, PIR, MPU6050, modulo LDR, modulo NTC, HX711 e cella di carico, gas MQ-2, fiamma, suono, inclinazioneDHT11 (usa il DHT22), sensori di colore e di impronte
MovimentoServo, motore passo-passo, driver A4988, modulo relè, buzzerMotore DC e driver come l'L298N
Comunicazione e memoriaRTC DS1307, scheda microSD, 74HC595, I2C, SPI, UARTRFID RC522, nRF24L01, HC-05, SIM800L, GPS
Circuiti analogiciPotenziometro e moduli sensore analogiciVero 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.

  1. Incolla il codice che funziona in simulazione in un nuovo sketch dell'Arduino IDE oppure apri sketch.ino dallo zip scaricato.
  2. Installa ogni libreria di libraries.txt dal Gestore librerie dell'Arduino IDE.
  3. Nel codice Wi-Fi sostituisci Wokwi-GUEST con il nome della tua rete e la password.
  4. 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).
  5. 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

SintomoCausa probabileSoluzione
L'ESP32 non si connette al Wi-Fi e i puntini continuanoNome della rete sbagliato o password inseritaUsa WiFi.begin("Wokwi-GUEST", "", 6); il nome distingue maiuscole e minuscole
Errore No such file or directoryLa libreria non è in libraries.txtAggiungi la libreria dalla scheda Library Manager
Il LED non si accendeLED al contrario (A e C scambiati) o filo di GND mancanteCollega la gamba lunga A al resistore e C a GND
Una pressione incrementa il contatore di dueVengono simulati i rimbalzi del pulsanteAggiungi il debounce al codice o usa "bounce": "0" nelle prove
La simulazione è molto lentaStampa continua su Serial senza pause nel loopMetti un breve delay nel loop e riduci l'output inutile
ImportError: no module named in MicroPythonIl file del modulo non è nel progettoCrea un nuovo file dal menu e incolla il modulo
Il web server dell'ESP32 non si apre nel browserIl gateway gratuito consente solo connessioni dall'interno verso l'esternoUsa net.forward nell'estensione VS Code
Il progetto è sparitoHai lavorato senza accedereSalva con Save; sui progetti altrui scegli Save a copy
Prima di ampliare un progetto, duplica la versione funzionante con Save a copy e prova la nuova funzione sulla copia. Se qualcosa si rompe torni alla versione buona con un clic; questa abitudine ti prepara anche a usare git nei progetti veri.

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.

Vedi tutti i progetti
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108
Controllo LED ESP32 con pulsante (Push)
ES-2Principiante

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.

4.6(36)
57
Controllo LED ESP32 con pulsante (Toggle)
ES-3Principiante

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.

4.6(39)
59
Lettura dell'intensità luminosa con il modulo LDR ESP32
ES-11Principiante

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.

4.6(36)
55
Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
PI-2Principiante

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.

4.5(2)
7
Raspberry Pi Pico LED Controllato da Pulsante (Push)
PI-9Principiante
Premium

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.

11
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

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.

4.5(13)
22