Guias · 15 min de leitura

Tutorial do simulador Wokwi: execute ESP32, Arduino e Pico online

Simulador Wokwi para ESP32, Arduino e Pico: conexões com diagram.json, Wi-Fi, MicroPython, analisador lógico, extensão para VS Code e vantagens sobre o Tinkercad.

O simulador Wokwi é um simulador de eletrônica gratuito que permite executar projetos com ESP32, Arduino e Raspberry Pi Pico no navegador sem comprar nenhum componente. Você escreve o código, coloca LEDs, botões, displays e sensores ao lado da placa virtual e pressiona o botão verde de reprodução: o código é compilado, o LED acende, o texto aparece no OLED e o Monitor Serial começa a exibir a saída. Sua maior diferença em relação ao Tinkercad é o suporte ao ESP32 e ao Pico; você pode até conectar o ESP32 à internet real por uma rede Wi-Fi virtual e executar MicroPython no Pico.

Neste guia, você começará abrindo seu primeiro projeto em wokwi.com e depois aprenderá a conectar componentes com o mouse e pelo arquivo diagram.json, adicionar bibliotecas, testar Wi-Fi e o horário da internet em um ESP32, executar MicroPython no Pico, medir um sinal PWM com o analisador lógico e usar a mesma simulação dentro do VS Code. No final, verá quais sensores são compatíveis, em que a simulação difere de um circuito real e como compartilhar seu projeto.

Placa de desenvolvimento ESP32
O maior destaque do Wokwi é o suporte ao ESP32: Wi-Fi, PWM, ADC, I2C e SPI são simulados como na placa real.

O que é Wokwi e como funciona?

O Wokwi compila seu código na nuvem com compiladores reais e entrega o código de máquina resultante a um emulador de processador executado no navegador. Assim, na simulação de um Arduino Uno, as instruções do ATmega328P são executadas uma a uma, e a mesma abordagem se aplica ao ESP32 e ao RP2040. Por isso, recursos de hardware como millis(), interrupções, temporizadores, PWM, I2C e SPI se comportam como na placa real, e bibliotecas reais funcionam sem alterações. O Wokwi não calcula as correntes e tensões do circuito; ele modela os níveis digitais dos pinos e os valores fornecidos às entradas analógicas. Essa arquitetura o torna uma ferramenta poderosa para testar software embarcado, em vez de fundamentos de eletrônica.

RecursoWokwi
Onde funcionaNavegador (wokwi.com) e extensão para VS Code
PlacasArduino Uno, Nano, Mega; ESP32, ESP32-S3, ESP32-C3; Raspberry Pi Pico e Pico W
LinguagensArduino C++, MicroPython, CircuitPython (Pico), ESP-IDF
BibliotecasA maioria das bibliotecas do Gerenciador de Bibliotecas do Arduino (libraries.txt)
RedeWi-Fi virtual para ESP32 e Pico W: Wokwi-GUEST
Ferramenta de mediçãoAnalisador lógico de 8 canais; sem medições elétricas
ContaNão é necessária para testar; entre na conta para salvar um projeto
PreçoO uso básico é gratuito; recursos extras fazem parte de um plano pago

Quais placas o Wokwi suporta?

Cada componente no Wokwi tem um nome de tipo, que você verá no arquivo diagram.json. A tabela abaixo mostra os equivalentes no Wokwi das três plataformas abordadas neste blog. Em projetos mais antigos, você também pode encontrar wokwi-esp32-devkit-v1 para o ESP32; ambos simulam o mesmo chip ESP32, apenas a disposição dos pinos da placa é diferente.

PlacaNome de tipo no WokwiOpções de linguagemObservação
Arduino Unowokwi-arduino-uno (tipo de placa no diagram.json)Arduino C++ATmega328P, lógica de 5 V, simulação mais rápida
Arduino Nanowokwi-arduino-nano (tipo de placa no diagram.json)Arduino C++Mesmo chip do Uno, placa menor
Arduino Megawokwi-arduino-mega (tipo de placa no diagram.json)Arduino C++8 KB de SRAM, projetos com muitos pinos
ESP32 DevKitboard-esp32-devkit-c-v4Arduino C++, MicroPython, ESP-IDFWi-Fi sim, Bluetooth não
ESP32-S3 / ESP32-C3board-esp32-s3-devkitc-1 / board-esp32-c3-devkitm-1 (tipos de placa ESP32-S3 / ESP32-C3)Arduino C++, MicroPython, ESP-IDFFamílias mais recentes de ESP32
Raspberry Pi Picowokwi-pi-picoMicroPython, CircuitPython, Arduino C++RP2040, lógica de 3,3 V
Raspberry Pi Pico Wboard-pi-pico-wMicroPython, Arduino C++Com Wi-Fi

Seu primeiro projeto Wokwi no navegador, passo a passo

  1. Abra wokwi.com no navegador. A página inicial tem as seções Arduino, ESP32 e Raspberry Pi Pico; escolha uma para ver modelos prontos e projetos de exemplo.
  2. Para começar do zero, escolha o modelo Arduino Uno na seção Arduino. A tela se divide em duas: o editor de código (sketch.ino) à esquerda e a área do diagrama, onde o circuito é desenhado, à direita.
  3. Pressione o botão azul + acima da área à direita e digite LED na caixa de busca. O componente escolhido aparece perto da placa; arraste-o com o mouse até o lugar desejado.
  4. Adicione um Resistor e um Pushbutton da mesma forma. Ao clicar em um componente, abre-se um pequeno painel em que você pode mudar sua cor ou seu valor; ajuste o resistor para 220 Ω.
  5. Para desenhar um fio, clique na extremidade de um pino e depois no pino ao qual ele deve se conectar. Clique em um espaço vazio entre eles para dobrar o trajeto do fio. Clique em um fio para mudar sua cor ou excluí-lo com a tecla Delete.
  6. Digite seu código à esquerda ou cole o exemplo abaixo e pressione o botão verde de reprodução. A primeira compilação leva alguns segundos; depois, a simulação começa e, se você usar Serial.begin, o Monitor Serial abre na parte inferior.
  7. Enquanto a simulação estiver em execução, clique no botão com o mouse. Pressione o botão quadrado para parar. Para manter o projeto, pressione Save; na primeira vez, será solicitado que você entre na conta, e seu projeto receberá um link permanente.
Um projeto criado sem entrar na conta não é salvo; ele desaparece quando você fecha a aba. Ao abrir o projeto de outra pessoa, suas alterações não são gravadas no projeto dela; use Save a copy para copiá-lo para sua própria conta.

Primeiro circuito: alternar o estado de um LED com um botão

Você pode montar o primeiro experimento clássico, um botão e um LED, com a mesma lógica nas três placas. A perna longa do LED (ânodo, A no Wokwi) vai ao pino de saída por meio do resistor, e a perna curta (cátodo, C) vai ao GND. Um lado do botão se conecta ao pino de entrada e o outro ao GND; o código ativa o resistor de pull-up interno. Para calcular o resistor do LED do seu circuito, você pode usar a calculadora Resistor para LED.

ConexãoArduino UnoESP32Raspberry Pi Pico
Ânodo do LED (A), por um resistor de 220 ΩD13GPIO 18GP14
Cátodo do LED (C)GNDGNDGND
Terminal 1 do botãoD2GPIO 4GP2
Terminal 2 do botãoGNDGNDGND
Nível lógico5 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}

O botão do Wokwi apresenta repique como um botão real: em um único pressionamento, o contato abre e fecha por alguns milissegundos. Por isso o código espera 50 ms; remova essa espera e às vezes você verá o LED alternar de estado duas vezes. É um detalhe interessante que torna o aprendizado na simulação útil também em um circuito real. Você encontra a lógica de temporização explicada em detalhes no artigo millis em vez de delay.

diagram.json: conectar componentes por um arquivo

Tudo o que você desenha com o mouse é, na verdade, gravado no arquivo diagram.json do projeto. Você pode abri-lo pelas abas acima do editor de código, editá-lo manualmente ou copiá-lo para outro projeto. O arquivo tem três seções importantes: parts (os componentes, seus tipos, posições e configurações), connections (os fios) e a seção opcional dependencies. Este é o arquivo diagram.json do circuito com Uno acima:

Código
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}
CampoPara que serve?Exemplo
typeO tipo do componentewokwi-led, wokwi-dht22, board-ssd1306 (exemplos de tipo de componente)
idO nome do componente; os fios usam esse nomeled1, uno, esp
top / left / rotate (chaves de posição e rotação)Posição na tela (pixels) e ângulo de rotação"rotate": 90
attrsConfigurações específicas do componente"color": "red", "value": "220" (exemplo de configurações em attrs)
connectionsCada fio: [pino inicial, pino final, cor, trajeto]["uno:13", "r1:1", "green", []]
Formato do nome do pinopart-id:pin-name (formato id-do-componente:nome-do-pino)uno:GND.1, esp:18, pico:GP14, btn1:1.l (exemplos de nomes de pinos)

A maneira mais fácil de aprender os nomes dos pinos é passar o mouse sobre um pino na área do diagrama; o Wokwi mostra seu nome em uma pequena etiqueta. Os quatro terminais do botão se chamam 1.l, 2.l, 1.r, 2.r: os terminais com o mesmo número são conectados internamente, e pressionar o botão une 1 e 2. Defina o atributo bounce do botão como "0" para desativar o repique; atribua ao atributo key um valor como "1" e você também poderá pressioná-lo pelo teclado. Em circuitos grandes, editar diagram.json manualmente é muito mais rápido do que desenhar dezenas de fios um a um.

Adicionar bibliotecas: libraries.txt

Para instalar uma biblioteca Arduino no Wokwi, abra a aba Library Manager acima do editor de código, pressione o botão + e busque o nome da biblioteca. A biblioteca escolhida é adicionada como uma linha ao arquivo libraries.txt do projeto e instalada automaticamente na nuvem durante a compilação. Você também pode escrever o arquivo manualmente; cada linha contém uma biblioteca, com o nome que aparece no Gerenciador de Bibliotecas do Arduino:

Código
1# Wokwi Library List
2Adafruit SSD1306
3Adafruit GFX Library
4DHT sensor library
5Adafruit NeoPixel
Se a compilação mostrar o erro No such file or directory, a biblioteca não está em libraries.txt ou seu nome está escrito incorretamente. Para aprender a instalar a biblioteca no Arduino IDE real, veja o artigo Como instalar uma biblioteca no Arduino.

Interagir com sensores: mudar valores durante a simulação

O mais instrutivo do Wokwi é poder ajustar os valores dos sensores com o mouse. Enquanto a simulação estiver em execução, clique no DHT22 para abrir os controles deslizantes de temperatura e umidade; clique no HC-SR04 para escolher uma distância entre 2 e 400 cm. O sensor PIR tem um botão que simula movimento, o potenciômetro tem um controle giratório e o módulo LDR tem um controle deslizante de intensidade luminosa (lux). Isso permite testar uma condição como “ligar a ventoinha quando a temperatura passar de 30 °C” em segundos e verificar os limites no código sem ter o sensor real.

Simulação de Wi-Fi com ESP32

O ESP32 no Wokwi se conecta a um ponto de acesso virtual chamado Wokwi-GUEST. Essa rede não tem senha e funciona no canal 6; especificar o canal acelera a conexão. A rede acessa a internet real pelo gateway do Wokwi: você pode obter o horário por NTP, enviar requisições HTTP a um servidor ou publicar dados em um broker MQTT. O código abaixo conecta o ESP32, imprime seu endereço IP e busca o horário de Istambul na internet.

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}

Ao usar esse código em um ESP32 real, basta digitar o nome e a senha da sua rede; você pode remover o parâmetro do canal. No plano gratuito, o ESP32 pode se conectar à internet, mas o navegador do seu computador não consegue acessar diretamente um servidor web executado dentro do ESP32. Para isso, você precisa do redirecionamento de portas da extensão para VS Code ou do gateway privado do plano pago. Para detalhes sobre NTP e fuso horário, veja Horário por NTP com ESP32; para problemas de conexão em uma placa real, veja ESP32 não conecta ao Wi-Fi.

O Wokwi simula o Wi-Fi do ESP32, mas Bluetooth e BLE não são simulados. O código com BLE ou Bluetooth clássico compila, mas não aparece nenhum dispositivo ao qual você possa se conectar pelo celular; você precisa testar essas partes em uma placa real.

Suporte a Raspberry Pi Pico e MicroPython

Placa Raspberry Pi Pico
No Wokwi, você pode executar o Pico com MicroPython e testar seu código no navegador antes de passar para o Thonny.

Ao escolher o modelo MicroPython para o Pico na página inicial, o projeto abre com um arquivo main.py. Pressione o botão de reprodução e o interpretador MicroPython será carregado, main.py será executado e você verá a saída de print no console abaixo. Quando o programa termina, o mesmo console entra no REPL, onde você pode digitar comandos e experimentar imediatamente. Se precisar de módulos extras, como o driver SSD1306, crie um novo arquivo pelo menu de arquivos e cole o conteúdo do módulo. O mesmo vale para o ESP32: basta escolher o modelo MicroPython na seção 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)

No código, o LED está no GP14, o botão no GP2 e o cursor do potenciômetro no GP26 (ADC0); os terminais externos do potenciômetro vão a 3V3 e GND. O ADC do Pico é de 12 bits, mas read_u16() do MicroPython retorna um valor escalonado de 0–65535. Se você está começando com MicroPython, o artigo Fundamentos de MicroPython explica um a um os comandos Pin, ADC, PWM e de temporização.

Visualizar sinais com o analisador lógico

O Wokwi não tem multímetro, mas tem uma ferramenta muito mais poderosa: o Logic Analyzer. Adicione-o pela lista de componentes e ele registrará 8 canais digitais (D0–D7). Conecte os canais aos pinos que deseja medir e o GND dele ao GND da placa. Ao parar a simulação, o registro é baixado como arquivo .vcd; abra-o em programas gratuitos, como PulseView ou GTKWave, para ler a frequência e a largura de pulso do sinal e até decodificar bytes de UART, I2C ou 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}

Ao abrir o registro, o canal D0 mostra uma onda quadrada com período de aproximadamente 2,04 ms (490 Hz); o pulso permanece em nível alto por um quarto do período, cerca de 0,51 ms. Isso ocorre porque analogWrite(9, 64) corresponde a um ciclo de trabalho de 64/255 ≈ 25%. No Uno, os pinos 5 e 6 produzem 980 Hz e os outros pinos PWM, 490 Hz; você pode verificar isso com o analisador. Adicione um decodificador UART ao canal D1 no PulseView e você lerá o byte 0x41 (A) a cada 100 ms. Para entender como o PWM funciona, veja O que é PWM?.

A extensão Wokwi para VS Code

Para projetos maiores, se preferir usar seu próprio editor em vez do navegador, você pode instalar a extensão Wokwi Simulator no VS Code. A extensão não compila o código; ela simula o arquivo de firmware gerado com PlatformIO, ESP-IDF ou arduino-cli. O uso pessoal funciona com uma licença gratuita que você renova periodicamente. A configuração tem estes passos:

  1. No VS Code, busque Wokwi Simulator na visualização Extensões e instale a extensão.
  2. Abra a paleta de comandos com F1, execute Wokwi: Request a New License e confirme a licença na página que abrir no navegador.
  3. Adicione um arquivo wokwi.toml e um arquivo diagram.json à raiz da pasta do projeto. Você pode copiar diagram.json de um projeto desenhado no navegador.
  4. Compile o projeto como de costume (Build no PlatformIO). Os caminhos em wokwi.toml devem apontar para os arquivos .bin e .elf compilados.
  5. Pressione F1 e execute Wokwi: Start Simulator. A simulação abre em uma aba do VS Code; quando você altera o código e compila novamente, a simulação reinicia.
Código
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"

A seção net.forward aqui redireciona o servidor web da porta 80 do ESP32 para a porta 8180 do seu computador. Assim, você pode abrir projetos como o Servidor web e WebSocket com ESP32 no próprio navegador sem gravar o firmware em uma placa. A extensão também suporta depuração passo a passo com GDB; adicione uma linha gdbServerPort a wokwi.toml e conecte o depurador do VS Code.

Diferenças entre Wokwi e Tinkercad

Os dois simuladores são gratuitos e funcionam no navegador, mas atendem a necessidades diferentes. O Tinkercad faz os cálculos elétricos do circuito: você pode medir a corrente em um resistor ou a tensão em um LED com um multímetro, e ele suporta programação em blocos. O Wokwi emula o processador da placa e oferece ESP32, Pico, Wi-Fi, MicroPython e amplo suporte a bibliotecas. Começar os fundamentos de eletrônica no Tinkercad e os projetos com ESP32 e IoT no Wokwi é o caminho mais eficiente. Para conhecer o Tinkercad em detalhes, veja o guia Simulador Arduino Tinkercad.

RecursoWokwiTinkercad Circuits
PlacasUno, Nano, Mega, família ESP32, Pico, Pico WArduino Uno R3, ATtiny, micro:bit
Cálculos elétricosNenhum; níveis digitais e um modelo de valores analógicosSim; multímetro e osciloscópio
Wi-Fi e internetSim, com ESP32 e Pico WNão
MicroPythonSim, no Pico e no ESP32Não
BibliotecasA maioria das disponíveis no Gerenciador de BibliotecasCerca de onze bibliotecas integradas
Programação em blocosNãoSim
Arquivo do circuitodiagram.json, editável manualmenteApenas editor visual
MediçãoAnalisador lógico (.vcd)Multímetro, osciloscópio
DesktopExtensão para VS CodeNão

Sensores e módulos compatíveis

GrupoDisponível no WokwiAusente ou limitado
Luz e displaysLED, LED RGB, fita e anel NeoPixel, LCD 16x2 e 20x4 (incluindo I2C), OLED SSD1306, TFT ILI9341, matriz MAX7219, TM1637, display de 7 segmentosDisplays de papel eletrônico e a maioria dos OLEDs coloridos
EntradaBotão, chave, chave DIP, potenciômetro, encoder rotativo (KY-040), joystick, teclado matricial de membrana, receptor IR e controle remotoTela sensível ao toque
SensoresDHT22, DS18B20, HC-SR04, PIR, MPU6050, módulo LDR, módulo NTC, HX711 e célula de carga, sensor de gás MQ-2, sensores de chama, som e inclinaçãoDHT11 (use DHT22), sensores de cor e de impressão digital
MovimentoServo, motor de passo, driver A4988, módulo relé, buzzerMotor CC e drivers de motor como o L298N
Comunicação e armazenamentoRTC DS1307, cartão microSD, 74HC595, I2C, SPI, UARTRC522 RFID, nRF24L01, HC-05, SIM800L, GPS
Circuitos analógicosPotenciômetro e módulos de sensores analógicosCálculos analógicos reais de transistores, amplificadores operacionais e capacitores

Para um componente que não está na lista, você tem duas opções. A primeira é usar um componente com comportamento semelhante; por exemplo, testar código do DHT11 com o componente DHT22. A segunda é o recurso Custom Chips: um pequeno programa escrito por você em C é compilado para WebAssembly e adicionado ao circuito como um novo componente com seus próprios pinos. Assim, você pode modelar por conta própria um sensor I2C simples ou um módulo que se comunica por UART.

Limites da simulação: diferenças em relação a um circuito real

  • Sem cálculos elétricos: Um LED ligado sem resistor continua aceso, e aplicar 5 V a um pino do ESP32 não queima nada. Em um circuito real, as duas situações causam perda de componentes. Calcule você mesmo a corrente e a tensão com a lei de Ohm.
  • Velocidade: O indicador no canto da área do diagrama mostra a velocidade da simulação como porcentagem do tempo real. Projetos com ESP32 que usam Wi-Fi ou têm muitos componentes podem rodar mais devagar que o tempo real; leve isso em conta no código que mede intervalos de tempo.
  • Sensores ideais: Os sensores virtuais não têm ruído e não precisam de calibração. Um DHT22 real tem desvio de ±0,5 °C, e um HC-SR04 faz leituras incorretas em superfícies macias; implemente filtragem e verificações de erro mesmo assim.
  • Sem alimentação ou bateria: Consumo de corrente, queda de tensão, aquecimento do regulador e brownouts não aparecem na simulação.
  • Sem Bluetooth: Os recursos BLE e Bluetooth clássico do ESP32 não são simulados.
  • Erros de conexão: Problemas reais como jumper solto, linha errada da protoboard ou solda fria não existem; um circuito que funciona na simulação pode não funcionar na primeira tentativa na prática.

Compartilhar um projeto e levá-lo para uma placa real

Cada projeto salvo recebe um endereço permanente; use o botão Share para copiar o link e enviá-lo a um amigo, educador ou fórum. Quem abre o link executa o projeto com um clique e pode copiá-lo para a própria conta para fazer alterações. Isso torna o Wokwi a maneira mais rápida de mostrar seu circuito e código juntos quando você pede ajuda dizendo “meu código não funciona”. No menu ao lado do botão Save, você pode baixar o projeto como um arquivo zip contendo sketch.ino, diagram.json e libraries.txt.

  1. Cole o código que funciona na simulação em um novo sketch no Arduino IDE ou abra sketch.ino do zip que você baixou.
  2. Instale todas as bibliotecas de libraries.txt pelo Gerenciador de Bibliotecas do Arduino IDE.
  3. No código de Wi-Fi, substitua Wokwi-GUEST pelo nome e pela senha da sua própria rede.
  4. Transforme as conexões de diagram.json em uma tabela de pinos e monte o circuito na protoboard seguindo essa tabela. Não se esqueça de adicionar os resistores de que o Wokwi não precisou (resistor do LED, pull-ups do I2C).
  5. Selecione a placa e a porta e carregue o código. Se algo der errado, siga os passos do guia Erro ao carregar código no Arduino.

Ideias de projetos para testar no Wokwi

  • Estação meteorológica com OLED: Mostre temperatura e umidade na tela com um ESP32, um DHT22 e um SSD1306; altere os valores com os controles deslizantes. Para o código do display, veja o artigo sobre o display OLED SSD1306.
  • Sensor de estacionamento: Altere a frequência dos bipes do buzzer conforme a distância do HC-SR04 e teste todos os limites com o controle deslizante de distância. Os detalhes estão no artigo sobre o sensor de distância HC-SR04.
  • Animações NeoPixel: Teste transições de cores em um anel ou matriz WS2812B e crie os efeitos antes de pensar na fonte de alimentação para uma fita real. Veja LED WS2812B NeoPixel.
  • Automação residencial com MQTT: Envie a temperatura do ESP32 virtual para um broker MQTT. Siga o guia ESP32 com MQTT e Home Assistant para configurar.
  • Fechadura com senha no teclado matricial: Monte uma fechadura de porta com teclado matricial de membrana, servo e LCD e acompanhe as tentativas de senha incorreta no Monitor Serial.
  • Experimentos com interrupções: Leia o botão com attachInterrupt e use o analisador lógico para ver como o repique aumenta a contagem de interrupções. Veja Interrupções no Arduino.

Erros comuns e como corrigi-los

SintomaCausa provávelSolução
O ESP32 não conecta ao Wi-Fi, os pontos continuam aparecendoNome de rede incorreto ou uma senha foi inseridaUse WiFi.begin("Wokwi-GUEST", "", 6); o nome da rede diferencia maiúsculas de minúsculas
Erro No such file or directoryA biblioteca não está em libraries.txtAdicione a biblioteca pela aba Library Manager
O LED não acendeLED invertido (A e C trocados) ou falta o fio GNDConecte a perna longa A ao resistor e C ao GND
Um pressionamento do botão incrementa o contador duas vezesO repique do botão é simuladoAdicione debounce ao código ou use "bounce": "0" durante o teste
A simulação está muito lentaImpressão contínua em Serial sem espera no laçoColoque um delay curto em loop e reduza a saída desnecessária
ImportError: no module named no MicroPythonO arquivo do módulo não está no projetoCrie um novo arquivo pelo menu de arquivos e cole o módulo
O servidor web do ESP32 não abre no navegadorO gateway gratuito só permite conexões de dentro para foraUse net.forward na extensão para VS Code
O projeto desapareceuVocê trabalhou sem entrar na contaSalve com Save; no projeto de outra pessoa, escolha Save a copy
Antes de ampliar um projeto, duplique a versão que funciona com Save a copy e teste o novo recurso na cópia. Se algo der errado, você estará a um clique da versão que funciona; esse hábito também é uma boa preparação para usar git em projetos reais.

O Wokwi é a maneira mais prática de testar uma ideia antes de comprar componentes, compartilhar um erro junto com seu circuito e testar código de Wi-Fi com segurança, especialmente com ESP32 e Pico. A maioria dos projetos no app BlueGrays inclui um vídeo de simulação gravado com o circuito em execução no Wokwi; você pode ver quando o LED acende e como o display é atualizado antes de começar a montagem e depois montar o mesmo projeto na placa real com o esquema do circuito e o código passo a passo.

Perguntas frequentes

O Wokwi é gratuito?

Sim, a versão do Wokwi para navegador é gratuita para uso básico: você pode criar, salvar e compartilhar projetos e conectar um ESP32 à internet pelo Wi-Fi virtual. Recursos extras, como o gateway privado e compilações mais rápidas, fazem parte de um plano pago. A extensão para VS Code também funciona com uma licença gratuita para uso pessoal.

Como conectar um ESP32 ao Wi-Fi no Wokwi?

No código do ESP32, use Wokwi-GUEST como nome da rede e uma string vazia como senha: WiFi.begin("Wokwi-GUEST", "", 6). O último parâmetro, canal 6, acelera a conexão. Depois de conectado, o ESP32 pode acessar a internet real por NTP, HTTP e MQTT.

Wokwi ou Tinkercad: qual é melhor?

O Tinkercad é mais adequado para aprender fundamentos de eletrônica, medir corrente e tensão com multímetro e usar programação em blocos. O Wokwi se destaca em projetos que precisam de ESP32, Raspberry Pi Pico, Wi-Fi, MicroPython e muitas bibliotecas. Muitos alunos usam os dois.

Como adicionar uma biblioteca no Wokwi?

Abra a aba Library Manager acima do editor de código, pressione o botão +, busque a biblioteca e selecione-a. A biblioteca é adicionada ao arquivo libraries.txt e instalada automaticamente durante a compilação. Você também pode digitar o nome da biblioteca no arquivo manualmente, exatamente como aparece no Gerenciador de Bibliotecas do Arduino.

O Wokwi tem DHT11?

A lista de componentes do Wokwi inclui o DHT22, mas não o DHT11. Para testar um código escrito para DHT11, coloque um componente DHT22 no circuito e defina o tipo de sensor na biblioteca como DHT22. Ao passar para uma placa real, basta mudar o tipo de volta para DHT11.

Posso carregar o código do Wokwi em uma placa real?

Sim. Como o Wokwi executa código padrão de Arduino e MicroPython, você pode carregar o mesmo código em uma placa real com Arduino IDE ou Thonny. Basta instalar as bibliotecas, mudar o nome e a senha da rede Wi-Fi e adicionar ao circuito os resistores de que o Wokwi não precisou.

Ver todos os projetos
LED piscando com ESP32
ES-1Iniciante

LED piscando com ESP32

Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

4.7(37)
108
Controle de LED com botão no ESP32 (momentâneo)
ES-2Iniciante

Controle de LED com botão no ESP32 (momentâneo)

O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. Mostra como usar o pino de entrada digital e o resistor pull-up interno do ESP32. O modo INPUT_PULLUP dispensa um resistor externo.

4.6(36)
57
Controle de LED com botão no ESP32 (alternância)
ES-3Iniciante

Controle de LED com botão no ESP32 (alternância)

Cada vez que o botão é pressionado, o estado do LED muda: se estiver aceso, apaga; se estiver apagado, acende. É o padrão clássico de alternância. Com debounce, eliminamos o ruído mecânico dos contatos do botão para garantir uma única mudança a cada pressionamento.

4.6(39)
59
Leitura da intensidade da luz com módulo LDR e ESP32
ES-11Iniciante

Leitura da intensidade da luz com módulo LDR e ESP32

Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

4.6(36)
55
Raspberry Pi Pico: controle de LED externo (protoboard)
PI-2Iniciante

Raspberry Pi Pico: controle de LED externo (protoboard)

O próximo passo depois do LED integrado do Pico: conectar um LED externo na protoboard e controlá-lo pelo pino GP14. Você aprende a usar qualquer pino GPIO do Pico como saída, a polaridade do LED (terminal longo = ânodo/+, terminal curto = cátodo/–) e por que um resistor limitador de corrente (220Ω) é indispensável. Sem o resistor, passa corrente demais pelo LED e ele pode queimar.

4.5(2)
7
Raspberry Pi Pico: LED controlado por botão (enquanto pressionado)
PI-9Iniciante
Premium

Raspberry Pi Pico: LED controlado por botão (enquanto pressionado)

Primeiro projeto de entrada com o Pico — leitura de botão! O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. O grande passo depois das animações com LEDs: entrada de sinais do mundo para o Pico. Aprenda a usar Pin.IN (modo de entrada), Pin.PULL_UP (pull-up interno — padrão para botões) e a leitura com button.value(). LED no GP14, botão no GP2. Pressionado = LOW (0), solto = HIGH (1) — essa lógica invertida confunde no início, mas é padrão da indústria.

11
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

Conexão Wi-Fi STA com ESP32 e display LCD

Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

4.4(21)
38
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

Hora exata pela internet com ESP32 e NTP

O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

4.5(13)
22