Simulando ESP32, Arduino e Raspberry pi com o Wokwi

Introdução

Alguma vez você já quis simular um ESP32, Arduino ou, até mesmo, um Raspbery Pi Pico? Seja por conveniência, para garantir que o projeto funcione antes de implementá-lo ou até mesmo comprar os componentes, provavelmente, já. Se sim, vou lhe apresentar o Wokwi, um simulador excelente para seu projetos. Um simulador é uma ferramenta extremamente bem-vinda (e útil), principalmente se estiver ali, mesmo, em seu navegador. Dito isso, o Wokwi.com está aqui para ajudá-lo! Ele é uma ferramenta gratuita de simulação direto no navegador, em que você pode escrever seus próprios códigos e usar os microcontroladores com outros componentes, como LEDs, botões, displays (de 7 segmentos a OLED’s), potenciômetros e muitos outros. Também permite monitorar periféricos I2C e seriais. Além de tudo isso, continuamente são adicionados novos componentes.

Vantagens de usar o Wokwi

1. Não há espera por componentes ou download de softwares grandes. Seu navegador tem tudo o que você precisa para começar a codificar seu próximo projeto de IoT em segundos.
2. Erros não são um problema. Você não pode destruir o hardware virtual. Portanto, não se preocupe em fritar seus preciosos componentes. Além disso, ao contrário do hardware real, você sempre pode desfazer algo.
3. Fácil de obter ajuda e feedback. Compartilhar um link do seu projeto Wokwi é tudo que você precisa.
4. Ganhe confiança em seu código. Problemas separados de hardware e software.
5. Comunidade amigável para criadores. Um lugar para você compartilhar seus projetos, pedir ajuda e se inspirar.

Iniciando um projeto e conhecendo o Wokwi

Primeiro, acesse o site do simulador e, na tela inicial, escolha a placa que deseja utilizar.

Estrutura do Wokwi

1. Botões para salvar, compartilhar e fazer download do seu projeto;
2. Abas dos arquivos do seu projeto e o botão para adicionar bibliotecas (Library Manager);
3. Área da IDE para escrever o código;
4. Área do simulador com os componentes e placas;
5. Botões para iniciar ou pausar a simulação e adicionar placas e componentes;
6. Simulador da Serial.

Tela do wokwi

Quando se usa algum sensor que pode ter os valores editados, ao clicar no sensor, aparece uma janela para mudar os valores. Veja o exemplo, abaixo, do sensor DTH22:

Mais detalhes na documentação do site: Documentação

Projeto de um mini piano com Arduino UNO

Nesse projeto, vamos simular um Arduino UNO, botões e um buzzer, o resultado final é um mini piano com Arduino.

Código:

#include "pitches.h"

#define BUZZER_PIN 8

const uint8_t buttonPins[] = { 12, 11, 10, 9, 7, 6, 5, 4 };
const int buttonTones[] = { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5};
const int numTones = sizeof(buttonPins) / sizeof(buttonPins[0]);

void setup() {
  for (uint8_t i = 0; i < numTones; i++) {
  pinMode(buttonPins[i], INPUT_PULLUP);
  }
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  int pitch = 0;

  for (uint8_t i = 0; i < numTones; i++) {
    if (digitalRead(buttonPins[i]) == LOW) {
    pitch = buttonTones[i];
    }
  }

  if (pitch) {
  tone(BUZZER_PIN, pitch);
  } else {
  noTone(BUZZER_PIN);
  }
}

Link para o projeto: Mini Piano

Vídeo de Demonstração

Projeto de Display de 7-Segmentos com MicroPython para Raspberry Pi Pico

Nesse projeto, vamos simular a mais nova placa da família Raspberry, a Raspberry Pi Pico, com um display de 7 segmentos e uma chave do tipo switch. O resultado final é um contador crescente ou decrescente, dependendo da posição da chave.

Outra novidade é que, nesse exemplo, usamos MicroPython para programar o Raspberry. Para usa-la, basta criar um novo arquivo com a extensão .py. Se preferir usar C/C++, crie uma arquivo com a extensão .ino.

Código:

from machine import Pin
from utime import sleep

#       A
#      ---
#  F |  G  | B
#      ---
#  E |     | C
#      ---
#       D

pins = [
  Pin(2, Pin.OUT), # A
  Pin(3, Pin.OUT), # B
  Pin(4, Pin.OUT), # C
  Pin(5, Pin.OUT), # D
  Pin(6, Pin.OUT), # E
  Pin(8, Pin.OUT), # F
  Pin(7, Pin.OUT), # G
  Pin(0, Pin.OUT) # DP (not connected)
]

# Common anode 7 segment
digits = [
  [0, 0, 0, 0, 0, 0, 1, 1], # 0
  [1, 0, 0, 1, 1, 1, 1, 1], # 1
  [0, 0, 1, 0, 0, 1, 0, 1], # 2 
  [0, 0, 0, 0, 1, 1, 0, 1], # 3
  [1, 0, 0, 1, 1, 0, 0, 1], # 4
  [0, 1, 0, 0, 1, 0, 0, 1], # 5
  [0, 1, 0, 0, 0, 0, 0, 1], # 6
  [0, 0, 0, 1, 1, 1, 1, 1], # 7
  [0, 0, 0, 0, 0, 0, 0, 1], # 8
  [0, 0, 0, 1, 1, 0, 0, 1], # 9
  [0, 0, 0, 1, 0, 0, 0, 1], # a
  [1, 1, 0, 0, 0, 0, 0, 1], # b
  [0, 1, 1, 0, 0, 0, 1, 1], # C
  [1, 0, 0, 0, 0, 1, 0, 1], # d
  [0, 1, 1, 0, 0, 0, 0, 1], # E
  [0, 1, 1, 1, 0, 0, 0, 1], # F  
]

def reset():
  for pin in pins:
    pin.value(1)

reset()

switch = Pin(11, Pin.IN)

while True:
  if switch.value() == 1:
    for i in range(len(digits)):
      if switch.value() == 0:
        break;      
      for j in range(len(pins) - 1):
        pins[j].value(digits[i][j])
      sleep(0.5)
  else:
    for i in range(len(digits) - 1, -1, -1): 
      if switch.value() == 1:
        break;      
      for j in range(len(pins)):
        pins[j].value(digits[i][j])
      sleep(0.5)

Link para o projeto: Contador

Projeto MQTT com ESP32 e um módulo DHT22

Nesse projeto, vamos simular um ESP32 – Wifi  devkitc s1, um módulo DHT22 e o monitor serial. O resultado final é o ESP32 lendo os dados do módulo DHT22 (temperatura e humidade) e enviando via MQTT para um broker, similar a um outro projeto do blog: Sleep Modes no esp8266.

Para rodar esse simulação, é necessário instalar duas bibliotecas:

• EspMQTTClient;
• DHT sensor library for ESPx.

Para adicionar bibliotecas, basta clicar na aba Library Manager > Botão Mais Roxo > digitar a biblioteca que deseja e clicar nela ou fazer o upload. Em seguida, é só incluir no código.

Código:

/**
 * @file ESP32_DHT22_Send_MQTT.ino
 * @author Saulo Aislan
 * @brief Firmware que ler o sensor de temperatura, envia os dados via MQTT.
 * @version 0.1
 * 
 * @copyright Copyright (c) 2022
 * 
*/

#include "EspMQTTClient.h"
#include "DHTesp.h"

EspMQTTClient client(
  "Wokwi-GUEST",         // SSID WiFi
  "",                    // Password WiFi
  "test.mosquitto.org",  // MQTT Broker
  "mqtt-wokwi",          // Client
  1883                   // MQTT port
);

const int DHT_PIN = 15;

DHTesp dhtSensor;

void setup()
{
  Serial.begin(115200);

  dhtSensor.setup(DHT_PIN, DHTesp::DHT22);

  client.enableDebuggingMessages(); // Enable debugging messages sent to serial output
  client.enableHTTPWebUpdater(); // Enable the web updater. User and password default to values of MQTTUsername and MQTTPassword. These can be overridded with enableHTTPWebUpdater("user", "password").
  client.enableOTA(); // Enable OTA (Over The Air) updates. Password defaults to MQTTPassword. Port is the default OTA port. Can be overridden with enableOTA("password", port).
  client.enableLastWillMessage("TestClient/lastwill", "Vou ficar offline");
}

/**
 * @brief Ler os dados do Sensor imprime e envia via MQTT
 */
void lerEnviarDados() {
  TempAndHumidity  data = dhtSensor.getTempAndHumidity();
  Serial.println("Temp: " + String(data.temperature, 2) + "°C");
  Serial.println("Humidade: " + String(data.humidity, 1) + "%");
  Serial.println("---");

  client.publish("topicowokwi/Temp", String(data.temperature, 2) + "°C"); 
  client.publish("topicowokwi/Humidade", String(data.humidity, 1) + "%");
}

/**
 * @brief Esta função é chamada quando tudo estiver conectado (Wifi e MQTT),
 * para utilizá-la deve-se implemtentar o struct EspMQTTClient
 */
void onConnectionEstablished()
{
  // Subscribe no "topicowokwi/msgRecebida/#" e mostra a mensagem recebida na Serial
    client.subscribe("topicowokwi/msgRecebida/#", [](const String & topic, const String & payload) {
    Serial.println("Mensagem recebida no topic: " + topic + ", payload: " + payload);
  });

  lerEnviarDados();
}

void loop()
{
  client.loop(); // Executa em loop
}

Link para o projeto: Exemplo ESP32 wokwi

Observação: Para utilizar qualquer função que precisa se conectar com um WiFi, o Wokwi disponibiliza uma rede virtual, Wokwi-GUEST, que não precisar de senha. Para mais informações sobre WiFi, acesse o Guia WiFi ESP32. Para enviar e receber os dados via MQTT, você deve preencher a struct com os dados do WiFi do Wokwi e com os dados do servidor MQTT de sua preferência. No exemplo, utilizei o “test.mosquitto.org” na porta 1883:

EspMQTTClient client(
   "Wokwi-GUEST", // SSID WiFi
   "", // Password WiFi
   "test.mosquitto.org", // MQTT Broker
   "mqtt-wokwi", // Client 
   1883 // MQTT port 
);

Para visualizar os dados do broker MQTT, estou usando o MQTT Explorer, disponível nesse link. Mas, você pode usar o software de sua preferência. As configurações da conexão para esse exemplo são as seguintes:

No exemplo, são utilizados os tópicos de subscribe “topicowokwi/msgRecebida/”, de publish “topicowokwi/Temp” para a temperatura e “topicowokwi/Humidade” para a humidade. Você pode editar como que preferir, mas fique atento que é necessário mudar, também, no servidor MQTT. No caso, configurei o broker para ler nos tópicos “topicowokwi/Temp” e “topicowokwi/Humidade”. Para configurar os tópicos, basta clicar no botão ADVANCED, na tela de configuração, digitar o tópico e clicar em ADD:

Se tudo for configurado corretamente, os dados aparecerão da seguinte forma:

Vídeo de Demonstração

Detecção de erro e Serial

Além de simular diversos componentes, o Wokwi tem um detector de erros de sintaxe na IDE e um monitor serial no simulador.

Exemplo de Erro:

Exemplo do Monitor Serial:

Conclusão

Um simulador é muito bom para agilizar o trabalho de criação de projetos, evitando ter que montar um circuito toda vez que precisar mudar algo. Quando, junto ao simulador de hardware, temos uma IDE para o firmware, o trabalho fica muito mais rápido e fácil. O Wokwi é um excelente simulador. Contudo, nada substitui o circuito real. Então, o Wokwi pode até nós ajudar, mas implementar o circuito físico é essencial para o aprendizado. Para mais materiais como esse, continue acompanhando as postagens semanais do blog e não deixe de visitar nossa loja. Lá, você encontra todos os componentes necessários para desenvolver estes e muitos outros projetos!

Que a força esteja com vocês e até mais!

Sobre o Autor

Saulo Aislan Graduando em Tecnologia em Telemática pelo IFPB – Campus de Campina Grande – PB. Tenho experiência com os microcontroladores da família Arduino, ESP8266, ESP32, STM32 e microprocessador Raspberry Pi. Tenho projetos na áreas de IoTs voltada para a indústria 4.0, agroindústria e indústria aeroespacial civil utilizando LoRa, Bluetooth, ZigBee e Wi-Fi. Atualmente estudando e desenvolvendo em FreeRTOS para sistemas em tempo real com ESP32 e LoRaWan para Smart City e compartilhando alguns projetos no blog da Eletrogate.