Laboratório 09
Checklist — do Arduino para o ESP-IDF
- Projeto
framework = espidf(CMake,sdkconfig.defaults, imagem completa para o Wokwi) rodando umapp_main()com uma task (T1) - Wi-Fi e MQTT orientados a eventos (
esp_wifi+espressif/mqtt), com LWTonline/offlinee comandos chegando (T2) - Fila de eventos no lugar do
loop():esp_timer+ ADC oneshot calibrado + DHT22 publicando.../dhte.../adc(T3) - LEDC com dois timers (5 Hz e 25 kHz medidos no analisador lógico) e os modos
pot,remotoeauto(T4) - SSD1306 com
i2c_master+esp_lcd, a mesma tela do Lab 08, e o Node-RED do Lab 08 gravando o Lab 09 sem mudar nada além do tópico (T5) - NVS guardando modo e intervalo, diagnóstico em
.../diage comparação Arduino × ESP-IDF (T6) - Previsões P1–P5 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 20 · T4 15 · T5 15 ·
T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Até o Lab 08, o firmware usou framework = arduino: setup(), loop(), Serial, Ticker,
WiFi.h, PubSubClient e as bibliotecas da Adafruit. Por baixo de tudo isso sempre esteve o
ESP-IDF, o framework oficial da Espressif, com o FreeRTOS. O Arduino é uma camada de
conveniência em cima dele.
Nesta aula você tira essa camada. O mesmo firmware do Lab 08 (DHT22, potenciômetro, PWM, OLED,
MQTT, modos pot/remoto/auto) é reescrito em framework = espidf, em C, usando as APIs do
ESP-IDF 6.1. O circuito não muda, e o contrato MQTT (tópicos e JSON) também não. A prova de
que a migração deu certo é o Node-RED do Lab 08 continuar gravando e mostrando tudo sem perceber
a troca.
Objetivos
- Montar um projeto ESP-IDF no PlatformIO:
CMakeLists.txt, componentes,sdkconfige dependências pelo IDF Component Manager. - Trocar o
loop()que pergunta "tem algo?" por uma task do FreeRTOS que dorme numa fila e só acorda com eventos. - Usar Wi-Fi e MQTT orientados a eventos: quem reconecta e quem avisa.
- Usar os drivers do ESP-IDF com handles: ADC oneshot com calibração, LEDC com timers e
canais explícitos, I2C master e
esp_lcd. - Guardar configuração na NVS e medir o que a troca custou ou economizou (flash, RAM, pilha).
Material
- VS Code + PlatformIO + extensão Wokwi, com o circuito do Lab 07/08 (nenhuma mudança).
- O primeiro build com
framework = espidfbaixa o ESP-IDF 6.1 e o toolchain (~1,5 GB, 10 a 20 minutos). Faça-o antes da aula, com o T1. - O Node-RED com o fluxo do Lab 08 (para a T5) e o
mosquitto_sub/mosquitto_pubvia Docker. - O analisador lógico do Wokwi e o Surfer ou o PulseView (como na T3 do Lab 07).
| No Lab 08 (Arduino) | No Lab 09 (ESP-IDF) | Tarefa |
|---|---|---|
setup() / loop() | app_main() + uma task bloqueada numa fila | T1, T3 |
Serial.printf() | ESP_LOGI() / ESP_LOGW() / ESP_LOGE() | T1 |
delay(ms) | vTaskDelay(pdMS_TO_TICKS(ms)) | T1 |
lib_deps no platformio.ini | idf_component.yml e a pasta components/ | T1, T2 |
WiFi.begin() + WiFi.status() | esp_wifi + eventos WIFI_EVENT / IP_EVENT | T2 |
PubSubClient + mqtt.loop() | esp-mqtt (espressif/mqtt) com task e eventos próprios | T2 |
Ticker | esp_timer | T3 |
millis() | esp_timer_get_time() / 1000 | T3 |
analogRead() / analogReadMilliVolts() | adc_oneshot_read() + adc_cali_raw_to_voltage() | T3 |
DHT sensor library | componente dht22 (fornecido) | T3 |
ledcSetup() / ledcWrite() | ledc_timer_config() + ledc_channel_config() + ledc_set_duty() | T4 |
Wire + Adafruit_SSD1306 | i2c_master + esp_lcd_panel_ssd1306 | T5 |
Adafruit_GFX | componente gfx (fornecido, mesma fonte e algoritmos) | T5 |
Preferences | NVS (nvs_open, nvs_set_*, nvs_commit) | T6 |
Clonar o repositório do grupo
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-a/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-a.git && cd lab09-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-b/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-b.git && cd lab09-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-c/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-c.git && cd lab09-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-d/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-d.git && cd lab09-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-e/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-e.git && cd lab09-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-f/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-f.git && cd lab09-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-g/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-g.git && cd lab09-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-h/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-h.git && cd lab09-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-i/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-i.git && cd lab09-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-j/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-j.git && cd lab09-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-k/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-k.git && cd lab09-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-l/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-l.git && cd lab09-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-m/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-m.git && cd lab09-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-x/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-x.git && cd lab09-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-p/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-p.git && cd lab09-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab09-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab09-grupo-n/commits/main/
- Acessos: ACESSO-LAB09.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab09-grupo-n.git && cd lab09-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab09-grupo-n" && code . --profile "ESP32IO"
Envie o link do repositório do seu grupo no Moodle:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
Repositório do Grupo A para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo B para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo C para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo D para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo E para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo F para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo G para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo H para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo I para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo J para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo K para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo L para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo M para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo X para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo P para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo N para Laboratório 09:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.
Suba os containers
Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Disciplina: ELT73A - Sistemas Microcontrolados.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-a"
2. Gere o LAB IoT do grupo em docker\lab09-a:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-a-nodered && (del /q "data\lab09-a\flows.json" "data\lab09-a\flows_cred.json" "data\lab09-a\.flows*.backup" 2>nul & docker compose start lab09-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-b"
2. Gere o LAB IoT do grupo em docker\lab09-b:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-b-nodered && (del /q "data\lab09-b\flows.json" "data\lab09-b\flows_cred.json" "data\lab09-b\.flows*.backup" 2>nul & docker compose start lab09-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-c"
2. Gere o LAB IoT do grupo em docker\lab09-c:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-c-nodered && (del /q "data\lab09-c\flows.json" "data\lab09-c\flows_cred.json" "data\lab09-c\.flows*.backup" 2>nul & docker compose start lab09-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-d"
2. Gere o LAB IoT do grupo em docker\lab09-d:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-d-nodered && (del /q "data\lab09-d\flows.json" "data\lab09-d\flows_cred.json" "data\lab09-d\.flows*.backup" 2>nul & docker compose start lab09-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-e"
2. Gere o LAB IoT do grupo em docker\lab09-e:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-e-nodered && (del /q "data\lab09-e\flows.json" "data\lab09-e\flows_cred.json" "data\lab09-e\.flows*.backup" 2>nul & docker compose start lab09-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-f"
2. Gere o LAB IoT do grupo em docker\lab09-f:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-f-nodered && (del /q "data\lab09-f\flows.json" "data\lab09-f\flows_cred.json" "data\lab09-f\.flows*.backup" 2>nul & docker compose start lab09-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-g"
2. Gere o LAB IoT do grupo em docker\lab09-g:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-g-nodered && (del /q "data\lab09-g\flows.json" "data\lab09-g\flows_cred.json" "data\lab09-g\.flows*.backup" 2>nul & docker compose start lab09-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-h"
2. Gere o LAB IoT do grupo em docker\lab09-h:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-h-nodered && (del /q "data\lab09-h\flows.json" "data\lab09-h\flows_cred.json" "data\lab09-h\.flows*.backup" 2>nul & docker compose start lab09-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-i"
2. Gere o LAB IoT do grupo em docker\lab09-i:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-i-nodered && (del /q "data\lab09-i\flows.json" "data\lab09-i\flows_cred.json" "data\lab09-i\.flows*.backup" 2>nul & docker compose start lab09-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-j"
2. Gere o LAB IoT do grupo em docker\lab09-j:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-j-nodered && (del /q "data\lab09-j\flows.json" "data\lab09-j\flows_cred.json" "data\lab09-j\.flows*.backup" 2>nul & docker compose start lab09-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-k"
2. Gere o LAB IoT do grupo em docker\lab09-k:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-k-nodered && (del /q "data\lab09-k\flows.json" "data\lab09-k\flows_cred.json" "data\lab09-k\.flows*.backup" 2>nul & docker compose start lab09-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-l"
2. Gere o LAB IoT do grupo em docker\lab09-l:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-l-nodered && (del /q "data\lab09-l\flows.json" "data\lab09-l\flows_cred.json" "data\lab09-l\.flows*.backup" 2>nul & docker compose start lab09-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-m"
2. Gere o LAB IoT do grupo em docker\lab09-m:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-m-nodered && (del /q "data\lab09-m\flows.json" "data\lab09-m\flows_cred.json" "data\lab09-m\.flows*.backup" 2>nul & docker compose start lab09-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab09-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-x"
2. Gere o LAB IoT do grupo em docker\lab09-x:
py "%IOT_GEN%" --disciplina elt73a --lab lab09 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab09-x-nodered && (del /q "data\lab09-x\flows.json" "data\lab09-x\flows_cred.json" "data\lab09-x\.flows*.backup" 2>nul & docker compose start lab09-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Projeto ESP-IDF · 10 pts
- T2 — Wi-Fi e MQTT por eventos · 20 pts
- T3 — Fila, timers e sensores · 20 pts
- T4 — PWM com LEDC e os modos de operacao · 15 pts
- T5 — Tela e o Node-RED do Lab 08 · 15 pts
- T6 — NVS, diagnostico e comparacao · 20 pts
O repositório nasce do lab09-template. Ele traz o circuito, o firmware do Lab 08 em
referencia/main_lab08.cpp (para consulta: é ele que você vai migrar) e dois componentes
prontos, que substituem bibliotecas do Arduino que não existem no ESP-IDF:
components/dht22/: leitura do DHT22 por um fio (o protocolo está comentado no.c);components/gfx/: texto, retângulos e círculo num framebuffer de 1024 bytes, com a mesma fonte e os mesmos algoritmos da Adafruit GFX. A tela sai idêntica, pixel a pixel.
Estrutura de Arquivos do Projeto
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📄CMakeLists.txt👈 Criar Aqui
- ├── 📄sdkconfig.defaults👈 Criar Aqui
- ├── 📄merge_firmware.py👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Edite Aqui
- ├── 🔧diagram.json👈 Verificar
- ├── 📄.gitignore👈 Verificar
- ├── 📂src
- ├── 📄CMakeLists.txt👈 Criar Aqui
- ├── 🚀idf_component.yml👈 Criar Aqui
- ├── 📄config.h👈 Criar Aqui
- ├── 📄main.c👈 Criar Aqui
- ├── 📄rede.h👈 Criar Aqui
- ├── 📄rede.c👈 Criar Aqui
- ├── 📄sensores.h👈 Criar Aqui
- ├── 📄sensores.c👈 Criar Aqui
- ├── 📄atuadores.h👈 Criar Aqui
- ├── 📄atuadores.c👈 Criar Aqui
- ├── 📄tela.h👈 Criar Aqui
- └── 📄tela.c👈 Criar Aqui
- ├── 📂components
- ├── 📄dht22👈 Verificar
- └── 📄gfx👈 Verificar
- ├── 📂referencia
- └── 📄main_lab08.cpp👈 Verificar
- ├── 📂evidencias
- ├── 📄t1-build.txt👈 Criar Aqui
- ├── 📄t1-serial.txt👈 Criar Aqui
- ├── 📄t2-serial.txt👈 Criar Aqui
- ├── 📄t2-mqtt.txt👈 Criar Aqui
- ├── 📄t3-mqtt.txt👈 Criar Aqui
- ├── 📄t4-mqtt.txt👈 Criar Aqui
- ├── 📄t4-pwm.png👈 Criar Aqui
- ├── 📄t5-oled.png👈 Criar Aqui
- ├── 📄t5-nodered.png👈 Criar Aqui
- ├── 📄t6-serial.txt👈 Criar Aqui
- └── 📝t6-comparacao.md👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Os mesmos do Lab 08, sob elt73a/lab09/grupo-x/: dht, adc, pwm, status, oled,
oled/fb e os comandos cmd/intervalo, cmd/modo, cmd/aquecedor e cmd/ventilador, com o
mesmo JSON. Novo só o .../diag (T6). Troque o X (e o #define GRUPO) pela letra do grupo.
Parte 1 — Projeto ESP-IDF
1.1 O que muda na estrutura
Um projeto ESP-IDF é um projeto CMake feito de componentes. O seu código (src/) é o
componente principal; components/ guarda os componentes do projeto; e o que vem da internet
(como o MQTT) fica em managed_components/, baixado pelo IDF Component Manager a partir do
idf_component.yml. A configuração do sistema (tick do FreeRTOS, partições, log, Wi-Fi…) fica no
sdkconfig, gerado a partir do sdkconfig.defaults.
platformio.ini framework = espidf, versão fixa da plataforma
CMakeLists.txt o projeto ESP-IDF (3 linhas)
sdkconfig.defaults o que muda em relação ao padrão (gera sdkconfig.esp32dev)
src/CMakeLists.txt o componente principal: fontes e de quais componentes ele depende
src/idf_component.yml dependências baixadas (espressif/mqtt) — T2
components/dht22, gfx componentes do projeto (fornecidos)
merge_firmware.py junta bootloader + partições + app para o Wokwi
1.2 Arquivos do projeto
[env:esp32dev]
; versão fixa: 7.1.0 traz o ESP-IDF 6.1 (sem a versão, cada aluno pode receber uma diferente)
platform = espressif32@7.1.0
board = esp32dev
framework = espidf
monitor_speed = 115200
monitor_filters = esp32_exception_decoder
; o Wokwi precisa da imagem completa (bootloader + partições + app) num arquivo só
extra_scripts = post:merge_firmware.py
# Projeto ESP-IDF (o PlatformIO usa este arquivo quando framework = espidf)
cmake_minimum_required(VERSION 3.22)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(lab09)
# sdkconfig.defaults — o que este projeto muda em relação ao padrão do ESP-IDF.
# O PlatformIO gera sdkconfig.esp32dev a partir daqui (apague-o para regenerar).
# flash de 4 MB e partição "grande" (1,5 MB de app): Wi-Fi + MQTT + TLS não cabem em 1 MB
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y
# tick do FreeRTOS em 1 ms (o padrão é 10 ms; o core Arduino usa 1000 Hz)
CONFIG_FREERTOS_HZ=1000
# log no monitor serial
CONFIG_LOG_DEFAULT_LEVEL_INFO=y
CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
Na T1, o componente principal tem só o main.c:
idf_component_register(SRCS "main.c"
INCLUDE_DIRS ".")
1.3 O Wokwi precisa da imagem completa
Com framework = arduino, o Wokwi carregava só o firmware.bin (o app). Com espidf ele
precisa da imagem completa da flash: bootloader em 0x1000, tabela de partições em 0x8000
e o app em 0x10000. O script abaixo roda depois de cada build e gera o firmware.merged.bin:
# merge_firmware.py — depois do build, junta bootloader + tabela de partições + app num único
# firmware.merged.bin (o que o Wokwi carrega com framework = espidf).
Import("env") # noqa: F821 (PlatformIO injeta 'env')
def juntar(source, target, env):
imagens = []
for offset, caminho in env.get("FLASH_EXTRA_IMAGES", []): # bootloader e partições
imagens += [offset, '"%s"' % env.subst(caminho)]
imagens += ["$ESP32_APP_OFFSET", '"$BUILD_DIR/${PROGNAME}.bin"']
env.Execute(" ".join([
'"$PYTHONEXE"', '"$OBJCOPY"', # $OBJCOPY = esptool.py
"--chip", env.BoardConfig().get("build.mcu", "esp32"),
"merge_bin", "-o", '"$BUILD_DIR/firmware.merged.bin"',
"--flash_mode", "dio", "--flash_size", "4MB",
] + imagens))
env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", juntar) # noqa: F821
[wokwi]
version = 1
# framework = espidf: a imagem completa (gerada pelo merge_firmware.py), não só o app
firmware = '.pio/build/esp32dev/firmware.merged.bin'
elf = '.pio/build/esp32dev/firmware.elf'
1.4 O primeiro programa
// ELT73A - Lab 09 (T1): o primeiro programa ESP-IDF
#include "esp_log.h"
#include "esp_system.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
static const char *TAG = "app";
// Uma task do FreeRTOS: no Arduino, o loop() era uma task escondida chamada "loopTask"
static void task_pisca(void *arg)
{
int n = 0;
for (;;) {
ESP_LOGI(TAG, "volta %d · heap livre %lu bytes", n++, (unsigned long)esp_get_free_heap_size());
vTaskDelay(pdMS_TO_TICKS(1000)); // dorme 1 s sem ocupar a CPU (o delay() do Arduino)
}
}
void app_main(void) // o setup() do ESP-IDF
{
ESP_LOGI(TAG, "=== Lab 09 - ola, ESP-IDF ===");
ESP_LOGW(TAG, "isto é um aviso"); // amarelo no monitor
ESP_LOGE(TAG, "isto é um erro"); // vermelho
xTaskCreate(task_pisca, "pisca", 3072, NULL, 5, NULL);
// app_main pode terminar: a task "pisca" continua rodando
}
Compile (PlatformIO: Build, ou pio run no terminal). A primeira vez demora: o PlatformIO baixa
o ESP-IDF 6.1 e o toolchain. Depois, inicie o Wokwi.
I (288) cpu_start: Multicore app
I (321) app_init: ESP-IDF: v6.1
I (360) main_task: Calling app_main()
I (360) app: === Lab 09 - ola, ESP-IDF ===
W (360) app: isto é um aviso
E (361) app: isto é um erro
I (361) app: volta 0 · heap livre 300144 bytes
I (1362) app: volta 1 · heap livre 304352 bytes
I (2362) app: volta 2 · heap livre 304352 bytes
Cada linha de log diz o nível (I, W, E), o tempo em ms desde o boot e a
etiqueta (TAG). Antes do app_main(), o próprio ESP-IDF já escreveu dezenas de linhas: o
bootloader, as partições, o FreeRTOS subindo as duas CPUs. No Arduino isso também acontecia, mas
ficava escondido.
P1: (a) o firmware completo do Lab 08 (Arduino) tem quantos KB? Anote o que o pio run
mostra no fim (Flash: [=== ] xx.x% (used ... bytes ...)). E este "olá" em ESP-IDF, que só tem
uma task? Ele vai ser maior ou menor que o Lab 08? E que um "olá" em Arduino? (b) No Arduino, o
loop() nunca termina. Aqui o app_main() termina logo depois do xTaskCreate(). Por que o
programa não para? Quem chamava o loop() no Arduino?
Evidências: em evidencias/t1-build.txt, as últimas linhas do pio run (RAM e Flash) do
Lab 08 e deste T1; em evidencias/t1-serial.txt, o monitor serial com pelo menos 3 voltas.
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📄CMakeLists.txt👈 Criar Aqui
- ├── 📄sdkconfig.defaults👈 Criar Aqui
- ├── 📄merge_firmware.py👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Edite Aqui
- ├── 📂src
- ├── 📄CMakeLists.txt👈 Criar Aqui
- └── 📄main.c👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-build.txt👈 Criar Aqui
- └── 📄t1-serial.txt👈 Criar Aqui
git conferir platformio.ini CMakeLists.txt sdkconfig.defaults merge_firmware.py wokwi.toml src/CMakeLists.txt src/main.c evidencias/t1-build.txt evidencias/t1-serial.txt
Projeto ESP-IDF
git conferir platformio.ini CMakeLists.txt sdkconfig.defaults merge_firmware.py wokwi.toml src/CMakeLists.txt src/main.c evidencias/t1-build.txt evidencias/t1-serial.txt
git add platformio.ini CMakeLists.txt sdkconfig.defaults merge_firmware.py wokwi.toml src/CMakeLists.txt src/main.c evidencias/t1-build.txt evidencias/t1-serial.txt && git commit -m "T1: Projeto ESP-IDF" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 2 — Wi-Fi e MQTT por eventos
2.1 Quem pergunta e quem avisa
No Lab 08, o loop() perguntava a cada volta: WiFi.status()? mqtt.connected()? E chamava
mqtt.loop() para o PubSubClient processar a rede. Se o broker caísse, conectarMQTT() ficava
num while com delay(2000), e nada mais rodava.
No ESP-IDF, quem sabe que algo aconteceu avisa. O Wi-Fi e o TCP/IP publicam eventos no event loop do sistema, e você registra uma função (handler) para os que interessam. O esp-mqtt tem a própria task: conecta, responde aos PINGs, reconecta sozinho e chama o seu handler a cada evento.
2.2 MQTT é um componente gerenciado
No ESP-IDF 6, o cliente MQTT saiu de dentro do IDF: virou o componente espressif/mqtt do
registro de componentes. Declare-o
e o Component Manager baixa no próximo build (pasta managed_components/). O arquivo
dependencies.lock que aparece na raiz vai para o repositório: ele fixa as versões usadas.
# IDF Component Manager: no ESP-IDF 6 o cliente MQTT saiu do IDF e virou componente gerenciado.
# É baixado de components.espressif.com no primeiro build (pasta managed_components/).
dependencies:
espressif/mqtt: "^1.1.0"
idf_component_register(SRCS "main.c" "rede.c"
INCLUDE_DIRS "."
PRIV_REQUIRES esp_wifi esp_netif esp_event nvs_flash mqtt)
2.3 Código
Os pinos, as constantes e os tópicos ficam num config.h, usado por todos os arquivos:
// config.h — pinos, constantes e tópicos (os mesmos do Lab 08, agora em lab09)
#pragma once
#define GRUPO "a" // troque pela letra do seu grupo
#define LAB "lab09"
// ---- Wi-Fi e broker
#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_SENHA ""
#define WIFI_CANAL 6 // canal fixo: conecta mais rápido no Wokwi
#define MQTT_URI "mqtt://broker.hivemq.com:1883"
// ---- pinos (o circuito é o do Lab 07/08)
#define DHT_PIN GPIO_NUM_15
#define OLED_SDA GPIO_NUM_21
#define OLED_SCL GPIO_NUM_22
#define OLED_ADDR 0x3C
#define POT_CANAL ADC_CHANNEL_6 // GPIO34 = ADC1_CH6 (o ADC1 funciona junto com o Wi-Fi)
#define AQ_PIN GPIO_NUM_25 // "aquecedor": resistência -> PWM lento
#define VE_PIN GPIO_NUM_26 // "ventilador": ventoinha 4 fios -> 25 kHz
// ---- ADC
#define ADC_AMOSTRAS 16 // média de 16 leituras
#define ADC_BANDA 40 // publica só se mudar mais que ~1 % (40/4095)...
#define ADC_REPUB_US (10 * 1000 * 1000) // ...ou a cada 10 s
#define SP_MIN 20.0f // faixa do setpoint (°C)
#define SP_MAX 55.0f
// ---- PWM (LEDC)
#define AQ_FREQ_HZ 5
#define VE_FREQ_HZ 25000
#define PWM_BITS 8 // duty de 0 a 255
#define PWM_MAX ((1 << PWM_BITS) - 1)
#define HISTERESE 0.5f // controle ON/OFF: ±0,5 °C
// ---- tópicos
#define BASE "elt73a/" LAB "/grupo-" GRUPO
#define TOPICO_DADOS BASE "/dht"
#define TOPICO_STATUS BASE "/status"
#define TOPICO_OLED BASE "/oled"
#define TOPICO_OLED_FB BASE "/oled/fb"
#define TOPICO_ADC BASE "/adc"
#define TOPICO_PWM BASE "/pwm"
#define TOPICO_DIAG BASE "/diag" // T6
#define TOPICO_INTERVALO BASE "/cmd/intervalo"
#define TOPICO_CMD_MODO BASE "/cmd/modo"
#define TOPICO_CMD_AQ BASE "/cmd/aquecedor"
#define TOPICO_CMD_VE BASE "/cmd/ventilador"
// rede.h — Wi-Fi (esp_wifi) e MQTT (esp-mqtt). Substitui WiFi.h e PubSubClient.
#pragma once
#include <stdbool.h>
// Os callbacks rodam na task do esp-mqtt / do event loop, NÃO na task da aplicação:
// eles só devem copiar os dados e avisar a aplicação (fila), nunca mexer no estado direto.
typedef struct {
void (*ao_conectar)(void); // MQTT conectado (ou reconectado)
void (*ao_mudar)(void); // Wi-Fi/MQTT mudou (indicadores W/M)
void (*ao_receber)(const char *topico, const char *texto); // mensagem num tópico assinado
} rede_callbacks_t;
void rede_iniciar(const char *client_id, const rede_callbacks_t *cb);
bool rede_wifi_ok(void);
bool rede_mqtt_ok(void);
int rede_rssi(void); // dBm (0 se desconectado)
// Publica (QoS 0, sem retain). len < 0: usa strlen(dados). Devolve false se falhou.
bool rede_publicar(const char *topico, const char *dados, int len);
// rede.c — Wi-Fi e MQTT orientados a EVENTOS.
// No Arduino, o loop() perguntava "WiFi.status()?" e "mqtt.connected()?" a cada volta e chamava
// mqtt.loop(). Aqui ninguém pergunta: o ESP-IDF avisa (handlers) quando algo acontece, e o
// esp-mqtt tem a própria task que mantém a conexão, responde aos PINGs e reconecta sozinha.
#include "rede.h"
#include <string.h>
#include "config.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_wifi.h"
#include "mqtt_client.h"
static const char *TAG = "rede";
static esp_mqtt_client_handle_t mqtt;
static rede_callbacks_t cbs;
static volatile bool wifi_ok, mqtt_ok;
static bool mqtt_iniciado;
bool rede_wifi_ok(void) { return wifi_ok; }
bool rede_mqtt_ok(void) { return mqtt_ok; }
int rede_rssi(void)
{
wifi_ap_record_t ap;
return (wifi_ok && esp_wifi_sta_get_ap_info(&ap) == ESP_OK) ? ap.rssi : 0;
}
bool rede_publicar(const char *topico, const char *dados, int len)
{
if (!mqtt_ok) return false;
return esp_mqtt_client_publish(mqtt, topico, dados, len < 0 ? 0 : len, 0, 0) >= 0;
}
// ------------------------------------------------------------------ MQTT
static void ao_evento_mqtt(void *arg, esp_event_base_t base, int32_t id, void *dados)
{
esp_mqtt_event_handle_t ev = dados;
switch ((esp_mqtt_event_id_t)id) {
case MQTT_EVENT_CONNECTED:
ESP_LOGI(TAG, "MQTT conectado");
mqtt_ok = true;
esp_mqtt_client_publish(mqtt, TOPICO_STATUS, "online", 0, 1, 1); // retido (LWT)
// sessão limpa: a cada (re)conexão o broker esqueceu as assinaturas
esp_mqtt_client_subscribe(mqtt, TOPICO_INTERVALO, 0);
esp_mqtt_client_subscribe(mqtt, TOPICO_CMD_MODO, 0);
esp_mqtt_client_subscribe(mqtt, TOPICO_CMD_AQ, 0);
esp_mqtt_client_subscribe(mqtt, TOPICO_CMD_VE, 0);
cbs.ao_conectar();
cbs.ao_mudar();
break;
case MQTT_EVENT_DISCONNECTED:
ESP_LOGW(TAG, "MQTT desconectado (o esp-mqtt reconecta sozinho)");
mqtt_ok = false;
cbs.ao_mudar();
break;
case MQTT_EVENT_DATA: {
// tópico e dados NÃO terminam em '\0': copie e termine antes de usar como string
char topico[96], texto[16];
int nt = ev->topic_len < (int)sizeof(topico) - 1 ? ev->topic_len : (int)sizeof(topico) - 1;
int nd = ev->data_len < (int)sizeof(texto) - 1 ? ev->data_len : (int)sizeof(texto) - 1;
memcpy(topico, ev->topic, nt);
topico[nt] = '\0';
memcpy(texto, ev->data, nd);
texto[nd] = '\0';
cbs.ao_receber(topico, texto);
break;
}
case MQTT_EVENT_ERROR:
ESP_LOGW(TAG, "MQTT erro");
break;
default:
break;
}
}
static void iniciar_mqtt(const char *client_id)
{
esp_mqtt_client_config_t cfg = {
.broker.address.uri = MQTT_URI,
.credentials.client_id = client_id,
.session = {
.keepalive = 15, // como o PubSubClient
.last_will = {
.topic = TOPICO_STATUS,
.msg = "offline",
.qos = 1,
.retain = 1,
},
},
.buffer.size = 2048, // o framebuffer em base64 tem 1368 bytes
};
mqtt = esp_mqtt_client_init(&cfg);
esp_mqtt_client_register_event(mqtt, ESP_EVENT_ANY_ID, ao_evento_mqtt, NULL);
}
// ------------------------------------------------------------------ Wi-Fi
static void ao_evento_wifi(void *arg, esp_event_base_t base, int32_t id, void *dados)
{
if (base == WIFI_EVENT && id == WIFI_EVENT_STA_START) {
ESP_LOGI(TAG, "conectando a %s", WIFI_SSID);
esp_wifi_connect();
} else if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
if (wifi_ok) cbs.ao_mudar();
wifi_ok = false;
ESP_LOGW(TAG, "Wi-Fi caiu, tentando de novo");
esp_wifi_connect(); // reconexão: aqui, e não no loop()
} else if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
ip_event_got_ip_t *ev = dados;
ESP_LOGI(TAG, "Wi-Fi conectado, IP " IPSTR, IP2STR(&ev->ip_info.ip));
wifi_ok = true;
cbs.ao_mudar();
if (!mqtt_iniciado) { // só na primeira vez: depois o esp-mqtt
mqtt_iniciado = true; // se reconecta sozinho
esp_mqtt_client_start(mqtt);
}
}
}
void rede_iniciar(const char *client_id, const rede_callbacks_t *cb)
{
cbs = *cb;
ESP_ERROR_CHECK(esp_netif_init());
esp_netif_create_default_wifi_sta();
wifi_init_config_t wcfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&wcfg));
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, ao_evento_wifi, NULL));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, ao_evento_wifi, NULL));
wifi_config_t sta = {
.sta = {
.ssid = WIFI_SSID,
.password = WIFI_SENHA,
.channel = WIFI_CANAL,
.threshold.authmode = WIFI_AUTH_OPEN,
},
};
iniciar_mqtt(client_id);
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta));
ESP_ERROR_CHECK(esp_wifi_start());
}
E o main.c da T2, que só liga a rede e registra no log o que acontece:
// ELT73A - Lab 09 (T2): Wi-Fi e MQTT orientados a eventos
#include <stdio.h>
#include "config.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "nvs_flash.h"
#include "rede.h"
static const char *TAG = "app";
// Por enquanto os callbacks só registram no log. Na T3 eles passam a pôr eventos numa fila.
static void ao_conectar(void) { ESP_LOGI(TAG, "conectado ao broker"); }
static void ao_mudar(void) { ESP_LOGI(TAG, "Wi-Fi %s · MQTT %s", rede_wifi_ok() ? "ok" : "--", rede_mqtt_ok() ? "ok" : "--"); }
static void ao_receber(const char *topico, const char *texto) { ESP_LOGI(TAG, "[CMD] %s <- '%s'", topico, texto); }
void app_main(void)
{
ESP_LOGI(TAG, "=== Lab 09 - T2: Wi-Fi + MQTT ===");
// o Wi-Fi guarda a calibração do rádio na NVS: ela precisa estar pronta antes
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
ESP_ERROR_CHECK(esp_event_loop_create_default()); // o "correio" dos eventos do sistema
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
static char client_id[32]; // static: o esp-mqtt guarda o ponteiro
snprintf(client_id, sizeof(client_id), "lab09-%s-%02X%02X", GRUPO, mac[4], mac[5]);
rede_callbacks_t cb = {.ao_conectar = ao_conectar, .ao_mudar = ao_mudar, .ao_receber = ao_receber};
rede_iniciar(client_id, &cb);
}
2.4 Testando
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-a/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-a/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-b/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-b/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-c/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-c/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-d/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-d/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-e/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-e/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-f/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-f/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-g/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-g/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-h/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-h/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-i/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-i/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-j/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-j/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-k/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-k/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-l/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-l/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-m/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-m/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-x/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-x/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-p/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-p/cmd/modo" -m auto
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab09/grupo-n/#' -v | tee /ev/t2-mqtt.txt"
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab09/grupo-n/cmd/modo" -m auto
- Rode no Wokwi com o terminal 1 aberto: aparece
status online. - Mande o comando do terminal 2: aparece
[CMD] ... <- 'auto'no serial. - Pare a simulação: depois de ~20 s (1,5 × o keepalive de 15 s), o broker publica o LWT
status offline.
I (360) app: === Lab 09 - T2: Wi-Fi + MQTT ===
I (980) rede: conectando a Wokwi-GUEST
I (2410) rede: Wi-Fi conectado, IP 10.10.0.2
I (2410) app: Wi-Fi ok · MQTT --
I (3120) rede: MQTT conectado
I (3120) app: conectado ao broker
I (3130) app: Wi-Fi ok · MQTT ok
I (9540) app: [CMD] elt73a/lab09/grupo-a/cmd/modo <- 'auto'
P2: (a) no Lab 08, com o broker fora do ar, o que acontecia com a leitura do potenciômetro e
com a tela enquanto conectarMQTT() esperava? E aqui, com o esp-mqtt reconectando na task dele?
(b) Os handlers rodam na task do esp-mqtt e na do event loop, e não na sua. Por que o
rede.c copia o tópico e o texto para buffers próprios antes de chamar ao_receber(), em vez de
passar os ponteiros do evento? (c) Por que o client_id do main.c é static?
Evidências: o serial em evidencias/t2-serial.txt e a saída do terminal 1 (com online, o
comando e o offline depois de parar a simulação) em evidencias/t2-mqtt.txt.
- ├── 📂src
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 🚀idf_component.yml👈 Criar Aqui
- ├── 📄config.h👈 Criar Aqui
- ├── 📄rede.h👈 Criar Aqui
- ├── 📄rede.c👈 Criar Aqui
- └── 📄main.c👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t2-serial.txt👈 Criar Aqui
- └── 📄t2-mqtt.txt👈 Criar Aqui
git conferir src/CMakeLists.txt src/idf_component.yml src/config.h src/rede.h src/rede.c src/main.c evidencias/t2-serial.txt evidencias/t2-mqtt.txt
Wi-Fi e MQTT por eventos
git conferir dependencies.lock src/CMakeLists.txt src/idf_component.yml src/config.h src/rede.h src/rede.c src/main.c evidencias/t2-serial.txt evidencias/t2-mqtt.txt
git add dependencies.lock src/CMakeLists.txt src/idf_component.yml src/config.h src/rede.h src/rede.c src/main.c evidencias/t2-serial.txt evidencias/t2-mqtt.txt && git commit -m "T2: Wi-Fi e MQTT por eventos" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.
Parte 3 — Fila, timers e sensores
3.1 O loop() vira uma fila
No Lab 08, os Ticker só ligavam flags (leituraPendente, adcPendente), e o loop()
girava o tempo todo conferindo essas flags. Agora há várias tasks (a do esp-mqtt, a do event loop,
a dos timers), e flags soltas entre tasks são uma fonte de erro. A solução do FreeRTOS é uma
fila: quem detecta algo põe um evento na fila, e uma única task (app) tira os
eventos e mexe no estado. Enquanto a fila está vazia, a task dorme, sem gastar CPU.
Os tipos de evento e o que vai na fila:
// ------------------------------------------------------------------ eventos da fila
typedef enum {
EV_LER_DHT, // esp_timer do DHT22 (a cada intervalo)
EV_LER_ADC, // esp_timer do potenciômetro (10 Hz)
EV_MQTT_CONECTOU, // rede.c: (re)conectou ao broker
EV_REDE_MUDOU, // rede.c: Wi-Fi ou MQTT caiu/voltou (indicadores W/M)
EV_COMANDO, // rede.c: mensagem num tópico de comando
} tipo_evento_t;
typedef struct {
tipo_evento_t tipo;
char topico[64];
char texto[16];
} evento_t;
static QueueHandle_t fila;
static esp_timer_handle_t timer_dht, timer_adc;
Os callbacks dos timers e da rede só enfileiram:
// ------------------------------------------------------------------ callbacks -> fila
// Rodam em outras tasks (esp_timer, esp-mqtt, event loop): só põem um evento na fila.
static void enfileirar(tipo_evento_t tipo)
{
evento_t ev = {.tipo = tipo};
if (xQueueSend(fila, &ev, 0) != pdTRUE) ESP_LOGW(TAG, "fila cheia: evento %d perdido", tipo);
}
static void ao_timer(void *arg) { enfileirar((tipo_evento_t)(intptr_t)arg); }
static void ao_conectar(void) { enfileirar(EV_MQTT_CONECTOU); }
static void ao_mudar(void) { enfileirar(EV_REDE_MUDOU); }
static void ao_receber(const char *topico, const char *texto)
{
evento_t ev = {.tipo = EV_COMANDO};
strlcpy(ev.topico, topico, sizeof(ev.topico));
strlcpy(ev.texto, texto, sizeof(ev.texto));
if (xQueueSend(fila, &ev, 0) != pdTRUE) ESP_LOGW(TAG, "fila cheia: comando perdido");
}
O Ticker vira um esp_timer. O callback recebe o tipo do evento no argumento:
static esp_timer_handle_t criar_timer(const char *nome, tipo_evento_t tipo)
{
esp_timer_handle_t t;
esp_timer_create_args_t args = {
.callback = ao_timer,
.arg = (void *)(intptr_t)tipo,
.name = nome,
};
ESP_ERROR_CHECK(esp_timer_create(&args, &t));
return t;
}
3.2 Sensores
O ADC do ESP-IDF é um driver com handle: cria a unidade, configura o canal (atenuação e
resolução) e, à parte, cria a calibração, que converte o valor cru em mV. É o que o
analogReadMilliVolts() fazia escondido. O DHT22 usa o componente dht22 do template.
// sensores.h — potenciômetro (ADC oneshot + calibração) e DHT22.
#pragma once
#include <stdbool.h>
void sensores_iniciar(void);
// Média de ADC_AMOSTRAS leituras: valor cru (0..4095) e tensão calibrada (mV).
void sensores_ler_pot(int *raw, int *mv);
// DHT22: true se a leitura é válida.
bool sensores_ler_dht(float *t, float *h);
// sensores.c — no Arduino: analogRead(), analogReadMilliVolts() e dht.readTemperature().
// No ESP-IDF, o ADC é um "driver com handle": cria a unidade, configura o canal e, à parte,
// cria o esquema de calibração que converte o valor cru em milivolts.
#include "sensores.h"
#include "config.h"
#include "dht22.h"
#include "esp_adc/adc_cali.h"
#include "esp_adc/adc_cali_scheme.h"
#include "esp_adc/adc_oneshot.h"
#include "esp_log.h"
static const char *TAG = "sensores";
static adc_oneshot_unit_handle_t adc;
static adc_cali_handle_t cali; // NULL se o chip não tiver calibração gravada
void sensores_iniciar(void)
{
adc_oneshot_unit_init_cfg_t ucfg = {.unit_id = ADC_UNIT_1};
ESP_ERROR_CHECK(adc_oneshot_new_unit(&ucfg, &adc));
adc_oneshot_chan_cfg_t ccfg = {
.atten = ADC_ATTEN_DB_12, // ~0 a 3,1 V (o "ADC_11db" do Arduino)
.bitwidth = ADC_BITWIDTH_12, // 0..4095
};
ESP_ERROR_CHECK(adc_oneshot_config_channel(adc, POT_CANAL, &ccfg));
adc_cali_line_fitting_config_t kcfg = {
.unit_id = ADC_UNIT_1,
.atten = ADC_ATTEN_DB_12,
.bitwidth = ADC_BITWIDTH_12,
.default_vref = 1100, // usado se o eFuse não tiver a referência gravada
};
if (adc_cali_create_scheme_line_fitting(&kcfg, &cali) != ESP_OK) {
ESP_LOGW(TAG, "sem calibração do ADC: mV será estimado");
cali = NULL;
}
dht22_iniciar(DHT_PIN);
}
void sensores_ler_pot(int *raw, int *mv)
{
int soma = 0;
for (int i = 0; i < ADC_AMOSTRAS; i++) {
int v = 0;
adc_oneshot_read(adc, POT_CANAL, &v);
soma += v;
}
*raw = soma / ADC_AMOSTRAS;
if (cali == NULL || adc_cali_raw_to_voltage(cali, *raw, mv) != ESP_OK) {
*mv = *raw * 3100 / 4095; // estimativa linear, sem calibração
}
}
bool sensores_ler_dht(float *t, float *h)
{
esp_err_t err = dht22_ler(DHT_PIN, t, h);
if (err != ESP_OK) ESP_LOGW(TAG, "DHT22: %s", esp_err_to_name(err));
return err == ESP_OK;
}
Atualize o src/CMakeLists.txt com os fontes e componentes novos. A partir daqui ele fica igual
ao final:
# "src" é o componente principal. Os outros componentes ficam em components/ (dht22, gfx)
# ou vêm do IDF Component Manager (mqtt, declarado em idf_component.yml).
idf_component_register(
SRCS "main.c" "rede.c" "sensores.c" "atuadores.c" "tela.c"
INCLUDE_DIRS "."
PRIV_REQUIRES esp_wifi esp_netif esp_event nvs_flash esp_timer esp_adc
esp_driver_ledc esp_driver_i2c esp_driver_gpio esp_lcd mbedtls
mqtt dht22 gfx)
3.3 A task da aplicação
As funções do Lab 08 voltam quase iguais. Mudam só as chamadas: millis() vira
esp_timer_get_time() / 1000, Serial.printf vira ESP_LOGI, mqtt.publish vira
rede_publicar.
static void ler_adc(void)
{
sensores_ler_pot(&adc_raw, &adc_mv);
float sp = SP_MIN + adc_raw * (SP_MAX - SP_MIN) / 4095.0f;
setpoint = roundf(sp * 2) / 2; // passos de 0,5 °C
}
static void publicar_adc(void)
{
char payload[96];
snprintf(payload, sizeof(payload), "{\"raw\":%d,\"mv\":%d,\"sp\":%.1f}", adc_raw, adc_mv, setpoint);
rede_publicar(TOPICO_ADC, payload, -1);
raw_publicado = adc_raw;
t_adc_publicado = esp_timer_get_time();
}
static void ler_e_publicar(void)
{
float t, h;
if (!sensores_ler_dht(&t, &h)) return; // falha: descartada
seq++;
ultima_t = t;
ultima_h = h;
char payload[160];
snprintf(payload, sizeof(payload),
"{\"grupo\":\"%s\",\"seq\":%lu,\"t\":%.1f,\"h\":%.1f,\"uptime_ms\":%lu,\"intervalo_s\":%.1f}",
GRUPO, (unsigned long)seq, t, h, (unsigned long)(esp_timer_get_time() / 1000), intervalo_s);
bool ok = rede_publicar(TOPICO_DADOS, payload, -1);
ESP_LOGI(TAG, "[PUB] %s %s -> %s", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
controlar(); // no modo auto a temperatura decide
tela_suja = true;
}
A task app: na T3, trate EV_LER_ADC, EV_LER_DHT, EV_MQTT_CONECTOU e EV_REDE_MUDOU (os
outros casos entram na T4 e na T5). O código completo está no bloco recolhível no fim da Parte 5.
// É o antigo loop(): mas em vez de girar o tempo todo perguntando "tem algo?", ela DORME na fila
// e só acorda quando chega um evento. Todo o estado é mexido só aqui: sem disputa entre tasks.
static void task_app(void *arg)
{
evento_t ev;
for (;;) {
if (xQueueReceive(fila, &ev, portMAX_DELAY) != pdTRUE) continue;
switch (ev.tipo) {
case EV_LER_ADC:
ler_adc();
if (abs(adc_raw - raw_publicado) > ADC_BANDA) { // banda morta
ESP_LOGI(TAG, "[ADC] raw=%4d %4d mV SP=%.1f C", adc_raw, adc_mv, setpoint);
publicar_adc();
controlar();
tela_suja = true;
} else if (esp_timer_get_time() - t_adc_publicado >= ADC_REPUB_US) {
publicar_adc(); // "ainda estou aqui"
}
break;
case EV_LER_DHT:
ler_e_publicar();
break;
case EV_MQTT_CONECTOU:
publicar_adc(); // estado atual para quem
publicar_pwm(); // acabou de chegar
tela_suja = true;
break;
case EV_REDE_MUDOU:
tela_suja = true;
break;
case EV_COMANDO:
tratar_comando(ev.topico, ev.texto);
break;
}
if (tela_suja) {
tela_suja = false;
desenhar_tela();
publicar_tela_texto();
publicar_framebuffer();
}
}
}
void app_main(void)
{
ESP_LOGI(TAG, "=== Lab 09 - ESP-IDF: ADC + PWM + MQTT ===");
// NVS: o Wi-Fi guarda a calibração do rádio nela
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
ESP_ERROR_CHECK(esp_event_loop_create_default());
sensores_iniciar();
atuadores_iniciar();
ler_adc();
controlar();
tela_iniciar();
desenhar_tela();
fila = xQueueCreate(16, sizeof(evento_t));
timer_dht = criar_timer("dht", EV_LER_DHT);
timer_adc = criar_timer("adc", EV_LER_ADC);
// a task da aplicação na CPU 1; o Wi-Fi fica na CPU 0 (o DHT22 desliga interrupções ~5 ms)
xTaskCreatePinnedToCore(task_app, "app", 6144, NULL, 5, NULL, 1);
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
static char client_id[32];
snprintf(client_id, sizeof(client_id), "lab09-%s-%02X%02X", GRUPO, mac[4], mac[5]);
rede_callbacks_t cb = {.ao_conectar = ao_conectar, .ao_mudar = ao_mudar, .ao_receber = ao_receber};
rede_iniciar(client_id, &cb);
esp_timer_start_periodic(timer_dht, (uint64_t)(intervalo_s * 1e6f));
esp_timer_start_periodic(timer_adc, 100 * 1000); // 10 Hz
// app_main pode terminar: a task "app", os timers e o Wi-Fi continuam rodando
}
P3: (a) por que o callback do esp_timer não pode chamar sensores_ler_dht() direto?
Pense nos ~5 ms com as interrupções desligadas, e em quem mais depende da task do esp_timer.
(b) O que acontece com um evento quando a fila (16 posições) está cheia? Em que situação isso
poderia ocorrer? (c) A task app foi criada na CPU 1. Por que não na CPU 0, onde roda o Wi-Fi?
Evidências: em evidencias/t3-mqtt.txt, a saída do mosquitto_sub com .../dht e .../adc
(gire o potenciômetro de um extremo ao outro).
elt73a/lab09/grupo-a/status online
elt73a/lab09/grupo-a/adc {"raw":2047,"mv":1650,"sp":37.5}
elt73a/lab09/grupo-a/dht {"grupo":"a","seq":1,"t":24.5,"h":55.0,"uptime_ms":8123,"intervalo_s":5.0}
elt73a/lab09/grupo-a/adc {"raw":3001,"mv":2420,"sp":45.5}
- ├── 📂src
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 📄sensores.h👈 Criar Aqui
- ├── 📄sensores.c👈 Criar Aqui
- └── 📄main.c👈 Edite Aqui
- └── 📂evidencias
- └── 📄t3-mqtt.txt👈 Criar Aqui
git conferir src/CMakeLists.txt src/sensores.h src/sensores.c src/main.c evidencias/t3-mqtt.txt
Fila, timers e sensores
git conferir src/CMakeLists.txt src/sensores.h src/sensores.c src/main.c evidencias/t3-mqtt.txt
git add src/CMakeLists.txt src/sensores.h src/sensores.c src/main.c evidencias/t3-mqtt.txt && git commit -m "T3: Fila, timers e sensores" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.
Parte 4 — PWM com LEDC e os modos de operação
4.1 Timer e canal: o que o Arduino escondia
O LEDC tem timers (geram frequência e resolução) e canais (cada um usa um timer e
controla um pino). No ESP-IDF você escolhe os dois. No core Arduino 2.x, ledcSetup(canal, ...)
escolhe o timer pelo número do canal: timer = (canal / 2) % 4. Os canais 0 e 1 dividem o
timer 0: foi por isso que, no Lab 07, o ventilador foi para o canal 2. Aqui não há regra
escondida: o aquecedor usa o LEDC_TIMER_0 e o ventilador o LEDC_TIMER_1, escritos no código.
O outro detalhe é o relógio. 5 Hz com 8 bits pedem um divisor de 80 MHz ÷ (5 × 256) = 62 500,
e o divisor do LEDC vai só até ~1023. Com LEDC_AUTO_CLK, o driver procura um relógio que sirva:
o REF_TICK de 1 MHz dá 1 MHz ÷ (5 × 256) ≈ 781. Para 25 kHz, o APB de 80 MHz serve
(divisor 12,5).
// atuadores.h — PWM do aquecedor e do ventilador (LEDC).
#pragma once
#include <stdint.h>
void atuadores_iniciar(void);
uint32_t atuadores_duty(float pct); // 0..100 % -> 0..255
void atuadores_aplicar(float aq_pct, float ve_pct);
// atuadores.c — no Arduino 2.x: ledcSetup(canal, freq, bits) + ledcAttachPin + ledcWrite.
// No ESP-IDF a estrutura do periférico aparece: um TIMER gera a frequência e a resolução, e cada
// CANAL usa um timer e controla um pino. Aqui são dois timers, porque as frequências são diferentes.
#include "atuadores.h"
#include <math.h>
#include "config.h"
#include "driver/gpio.h" // no IDF 6, o ledc.h não inclui mais o gpio.h
#include "driver/ledc.h"
#include "esp_log.h"
static const char *TAG = "atuadores";
#define AQ_TIMER LEDC_TIMER_0
#define VE_TIMER LEDC_TIMER_1
#define AQ_CANAL LEDC_CHANNEL_0
#define VE_CANAL LEDC_CHANNEL_1
static void iniciar_timer(ledc_timer_t timer, uint32_t freq)
{
ledc_timer_config_t t = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.timer_num = timer,
.duty_resolution = LEDC_TIMER_8_BIT,
.freq_hz = freq,
.clk_cfg = LEDC_AUTO_CLK, // 5 Hz em 8 bits não cabe no relógio de 80 MHz:
}; // o driver escolhe o REF_TICK (1 MHz) sozinho
ESP_ERROR_CHECK(ledc_timer_config(&t));
ESP_LOGI(TAG, "timer %d: %lu Hz pedidos, %lu Hz obtidos", timer, (unsigned long)freq,
(unsigned long)ledc_get_freq(LEDC_LOW_SPEED_MODE, timer));
}
static void iniciar_canal(ledc_channel_t canal, ledc_timer_t timer, gpio_num_t pino)
{
ledc_channel_config_t c = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = canal,
.timer_sel = timer,
.gpio_num = pino,
.duty = 0,
.hpoint = 0,
};
ESP_ERROR_CHECK(ledc_channel_config(&c));
}
void atuadores_iniciar(void)
{
iniciar_timer(AQ_TIMER, AQ_FREQ_HZ);
iniciar_timer(VE_TIMER, VE_FREQ_HZ);
iniciar_canal(AQ_CANAL, AQ_TIMER, AQ_PIN);
iniciar_canal(VE_CANAL, VE_TIMER, VE_PIN);
}
uint32_t atuadores_duty(float pct) { return (uint32_t)lroundf(pct * PWM_MAX / 100.0f); }
static void escrever(ledc_channel_t canal, float pct)
{
ledc_set_duty(LEDC_LOW_SPEED_MODE, canal, atuadores_duty(pct)); // 1. prepara
ledc_update_duty(LEDC_LOW_SPEED_MODE, canal); // 2. aplica
}
void atuadores_aplicar(float aq_pct, float ve_pct)
{
escrever(AQ_CANAL, aq_pct);
escrever(VE_CANAL, ve_pct);
}
No ESP-IDF 6, o driver/ledc.h não inclui mais o driver/gpio.h. Sem o #include explícito,
gpio_num_t e GPIO_NUM_25 dão error: unknown type name. Vários headers "emagreceram" assim
na versão 6.
4.2 Controle e comandos
controlar() e o tratamento dos comandos são os do Lab 08, com duas mudanças: o comando de
intervalo usa strtof() (como os outros) e reinicia o esp_timer em vez do Ticker.
static void publicar_pwm(void)
{
char t[8] = "null";
if (!isnan(ultima_t)) snprintf(t, sizeof(t), "%.1f", ultima_t);
char payload[200];
snprintf(payload, sizeof(payload),
"{\"modo\":\"%s\",\"estado\":\"%s\",\"aq\":%.0f,\"ve\":%.0f,"
"\"aq_duty\":%lu,\"ve_duty\":%lu,\"sp\":%.1f,\"t\":%s}",
NOME_MODO[modo], estado, aq_pct, ve_pct,
(unsigned long)atuadores_duty(aq_pct), (unsigned long)atuadores_duty(ve_pct), setpoint, t);
rede_publicar(TOPICO_PWM, payload, -1);
ESP_LOGI(TAG, "[PWM] %s", payload);
}
static void controlar(void)
{
float aq = 0, ve = 0;
const char *novo_estado;
switch (modo) {
case MODO_POT: // potenciômetro = dimmer
aq = ve = adc_raw * 100.0f / 4095.0f;
novo_estado = "MANUAL";
break;
case MODO_REMOTO: // valores vindos do MQTT
aq = aq_remoto;
ve = ve_remoto;
novo_estado = "REMOTO";
break;
default: // ON/OFF com histerese
if (isnan(ultima_t)) {
novo_estado = "SEM DHT";
break;
}
if (ultima_t < setpoint - HISTERESE) aquecendo = true;
else if (ultima_t > setpoint + HISTERESE) aquecendo = false;
aq = aquecendo ? 100 : 0;
ve = fminf(fmaxf((ultima_t - setpoint - 1.0f) * 25.0f, 0.0f), 100.0f);
novo_estado = aquecendo ? "AQUECENDO" : (ultima_t > setpoint + 1.0f ? "RESFRIANDO" : "ESTAVEL");
break;
}
aq = roundf(aq);
ve = roundf(ve);
if (aq == aq_pct && ve == ve_pct && strcmp(novo_estado, estado) == 0) return; // nada mudou
aq_pct = aq;
ve_pct = ve;
estado = novo_estado;
atuadores_aplicar(aq_pct, ve_pct);
publicar_pwm();
tela_suja = true;
}
static void tratar_comando(const char *topico, const char *txt)
{
ESP_LOGI(TAG, "[CMD] %s <- '%s'", topico, txt);
if (strcmp(topico, TOPICO_INTERVALO) == 0) {
char *fim;
float v = strtof(txt, &fim);
if (fim == txt || v < 2.0f || v > 60.0f) {
ESP_LOGW(TAG, "[CMD] intervalo fora de 2..60 s - ignorado");
return;
}
intervalo_s = v;
esp_timer_stop(timer_dht); // o "detach() + attach()"
esp_timer_start_periodic(timer_dht, (uint64_t)(intervalo_s * 1e6f));
tela_suja = true;
} else if (strcmp(topico, TOPICO_CMD_MODO) == 0) {
int novo = -1;
for (int i = 0; i < 3; i++)
if (strcasecmp(txt, NOME_MODO[i]) == 0) novo = i;
if (novo < 0) {
ESP_LOGW(TAG, "[CMD] modo invalido (use pot, remoto ou auto)");
return;
}
modo = (modo_t)novo;
aquecendo = false;
controlar();
tela_suja = true;
} else if (strcmp(topico, TOPICO_CMD_AQ) == 0 || strcmp(topico, TOPICO_CMD_VE) == 0) {
char *fim;
float v = strtof(txt, &fim);
if (fim == txt || v < 0 || v > 100) {
ESP_LOGW(TAG, "[CMD] use 0..100 (%%)");
return;
}
if (strcmp(topico, TOPICO_CMD_AQ) == 0) aq_remoto = v;
else ve_remoto = v;
if (modo == MODO_REMOTO) controlar();
else ESP_LOGI(TAG, "[CMD] guardado; vale no modo remoto");
}
}
Na task app, trate EV_COMANDO chamando tratar_comando(ev.topico, ev.texto).
4.3 Medindo
Repita os comandos da T4 do Lab 07 (cmd/modo remoto, cmd/aquecedor 30, cmd/ventilador 80,
cmd/aquecedor 150, cmd/modo turbo, cmd/modo pot) e a sequência de temperaturas da T6
(modo auto, SP ≈ 37,5 °C: 24,5 → 37,4 → 38,2 → 41,0 → 37,8 → 36,8 °C). Depois, com o knob em
~25 % no modo pot, grave o analisador lógico e meça D0 e D1 no Surfer ou no PulseView.
I (420) atuadores: timer 0: 5 Hz pedidos, 5 Hz obtidos
I (425) atuadores: timer 1: 25000 Hz pedidos, 25000 Hz obtidos
I (431) app: [PWM] {"modo":"pot","estado":"MANUAL","aq":50,"ve":50,"aq_duty":128,"ve_duty":128,"sp":37.5,"t":null}
P4: (a) no Lab 07/08 (Arduino), o aquecedor usa o canal 0 e o ventilador o canal 2.
Se o ventilador tivesse ficado no canal 1, com o ledcSetup() dele vindo depois, que
frequência o D0 (aquecedor) teria, pela regra timer = (canal / 2) % 4? Aqui o ventilador está no
LEDC_CHANNEL_1: por que no ESP-IDF isso não é problema? (b) Por
que o ESP-IDF precisou de dois ledc_timer_config()? (c) O que o ledc_update_duty() faz que
o ledc_set_duty() sozinho não faz?
Evidências: a saída do mosquitto_sub com os comandos e as mensagens .../pwm em
evidencias/t4-mqtt.txt, e a captura do analisador com as duas medições em
evidencias/t4-pwm.png.
- ├── 📂src
- ├── 📄atuadores.h👈 Criar Aqui
- ├── 📄atuadores.c👈 Criar Aqui
- └── 📄main.c👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t4-mqtt.txt👈 Criar Aqui
- └── 📄t4-pwm.png👈 Criar Aqui
git conferir src/atuadores.h src/atuadores.c src/main.c evidencias/t4-mqtt.txt evidencias/t4-pwm.png
PWM com LEDC e os modos de operacao
git conferir src/atuadores.h src/atuadores.c src/main.c evidencias/t4-mqtt.txt evidencias/t4-pwm.png
git add src/atuadores.h src/atuadores.c src/main.c evidencias/t4-mqtt.txt evidencias/t4-pwm.png && git commit -m "T4: PWM com LEDC e os modos de operacao" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Parte 5 — Tela e o Node-RED do Lab 08
5.1 Três camadas, três handles
Wire.begin() + oled.begin() viram três objetos: o barramento I2C (i2c_master), o IO
do painel (como os bytes de comando e de dado vão pelo I2C) e o painel SSD1306 (esp_lcd).
O desenho continua num framebuffer na RAM, agora do componente gfx. tela_enviar() faz o papel
do oled.display(): manda os 1024 bytes.
// tela.h — SSD1306 por I2C (driver i2c_master + esp_lcd). O desenho é feito com o gfx.
#pragma once
#include <stdbool.h>
#include <stddef.h>
bool tela_iniciar(void); // false se o display não respondeu
void tela_enviar(void); // framebuffer do gfx -> display (1024 bytes)
// framebuffer em base64 (1368 caracteres + '\0'); devolve o tamanho ou 0 se não coube
size_t tela_base64(char *saida, size_t capacidade);
// tela.c — no Arduino: Wire.begin(21, 22) + oled.begin(SSD1306_SWITCHCAPVCC, 0x3C) + oled.display().
// No ESP-IDF são três camadas, cada uma com o seu handle:
// barramento I2C (i2c_master) -> "painel IO" I2C (esp_lcd) -> painel SSD1306 (esp_lcd)
// O desenho continua num framebuffer na RAM (gfx); tela_enviar() faz o papel do display().
#include "tela.h"
#include "config.h"
#include "driver/i2c_master.h"
#include "esp_lcd_io_i2c.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_ssd1306.h"
#include "esp_log.h"
#include "gfx.h"
#include "mbedtls/base64.h"
static const char *TAG = "tela";
static esp_lcd_panel_handle_t painel;
bool tela_iniciar(void)
{
i2c_master_bus_handle_t barramento;
i2c_master_bus_config_t bcfg = {
.i2c_port = I2C_NUM_0,
.sda_io_num = OLED_SDA,
.scl_io_num = OLED_SCL,
.clk_source = I2C_CLK_SRC_DEFAULT,
.glitch_ignore_cnt = 7,
.flags.enable_internal_pullup = true,
};
ESP_ERROR_CHECK(i2c_new_master_bus(&bcfg, &barramento));
if (i2c_master_probe(barramento, OLED_ADDR, 50) != ESP_OK) {
ESP_LOGE(TAG, "SSD1306 nao encontrado em 0x%02X - confira SDA/SCL/endereco", OLED_ADDR);
return false;
}
esp_lcd_panel_io_handle_t io;
esp_lcd_panel_io_i2c_config_t iocfg = {
.dev_addr = OLED_ADDR,
.scl_speed_hz = 400 * 1000,
.control_phase_bytes = 1, // byte de controle antes de cada comando/dado
.dc_bit_offset = 6, // bit "D/C" do byte de controle (datasheet do SSD1306)
.lcd_cmd_bits = 8,
.lcd_param_bits = 8,
};
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c(barramento, &iocfg, &io));
esp_lcd_panel_ssd1306_config_t scfg = {.height = 64};
esp_lcd_panel_dev_config_t pcfg = {
.bits_per_pixel = 1,
.reset_gpio_num = -1, // sem pino de reset (como o -1 da Adafruit)
.vendor_config = &scfg,
};
ESP_ERROR_CHECK(esp_lcd_new_panel_ssd1306(io, &pcfg, &painel));
ESP_ERROR_CHECK(esp_lcd_panel_reset(painel));
ESP_ERROR_CHECK(esp_lcd_panel_init(painel));
// a Adafruit inicia o SSD1306 espelhado nos dois eixos (0xA1, 0xC8); o esp_lcd, não
ESP_ERROR_CHECK(esp_lcd_panel_mirror(painel, true, true));
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(painel, true));
return true;
}
void tela_enviar(void)
{
if (painel) esp_lcd_panel_draw_bitmap(painel, 0, 0, GFX_W, GFX_H, gfx_buffer());
}
size_t tela_base64(char *saida, size_t capacidade)
{
size_t n = 0;
if (mbedtls_base64_encode((unsigned char *)saida, capacidade, &n, gfx_buffer(), GFX_FB_BYTES) != 0)
return 0;
return n;
}
5.2 Desenho e publicação
A tela do Lab 08 com as funções do gfx (oled.fillRect → gfx_retangulo_cheio,
oled.printf → gfx_printf…). Os espelhos em .../oled e .../oled/fb são os mesmos.
static void indicador(int x, const char *letra, bool ok)
{
if (ok) {
gfx_retangulo_cheio(x, 0, 13, 9, GFX_BRANCO);
gfx_cor_texto(GFX_PRETO);
} else {
gfx_retangulo(x, 0, 13, 9, GFX_BRANCO);
gfx_cor_texto(GFX_BRANCO);
}
gfx_cursor(x + 4, 1);
gfx_texto(letra);
gfx_cor_texto(GFX_BRANCO);
}
static void barra(int y, const char *rotulo, float pct)
{
gfx_cursor(0, y);
gfx_texto(rotulo);
gfx_retangulo(16, y, 80, 8, GFX_BRANCO);
gfx_retangulo_cheio(18, y + 2, (int)(76 * pct / 100.0f), 4, GFX_BRANCO);
gfx_cursor(100, y);
gfx_printf("%3.0f%%", pct);
}
static void desenhar_tela(void)
{
gfx_limpar();
gfx_cor_texto(GFX_BRANCO);
gfx_tamanho_texto(1); // cabeçalho
gfx_cursor(0, 1);
gfx_texto("LAB09 grupo " GRUPO);
indicador(98, "W", rede_wifi_ok());
indicador(114, "M", rede_mqtt_ok());
gfx_linha_h(0, 11, GFX_W, GFX_BRANCO);
gfx_tamanho_texto(2); // temperatura medida
gfx_cursor(0, 15);
if (isnan(ultima_t)) gfx_texto("--.-");
else gfx_printf("%4.1f", ultima_t);
gfx_circulo(53, 17, 2, GFX_BRANCO);
gfx_cursor(58, 15);
gfx_texto("C");
gfx_tamanho_texto(1); // setpoint e ADC
gfx_cursor(76, 15);
gfx_printf("SP %4.1f", setpoint);
gfx_cursor(76, 24);
gfx_printf("%4d mV", adc_mv);
barra(35, "AQ", aq_pct < 0 ? 0 : aq_pct); // atuadores
barra(45, "VE", ve_pct < 0 ? 0 : ve_pct);
gfx_cursor(0, 56); // modo e estado
gfx_printf("%s: %s", NOME_MODO[modo], estado);
tela_enviar();
}
static void publicar_tela_texto(void)
{
char t[8] = "--.-";
if (!isnan(ultima_t)) snprintf(t, sizeof(t), "%.1f", ultima_t);
char payload[220];
snprintf(payload, sizeof(payload),
"{\"linhas\":[\"LAB09 grupo %s\",\"T: %s C SP: %.1f C\",\"AQ: %.0f %% VE: %.0f %%\","
"\"modo %s | %s\",\"WiFi %s | MQTT %s\"]}",
GRUPO, t, setpoint, aq_pct < 0 ? 0 : aq_pct, ve_pct < 0 ? 0 : ve_pct,
NOME_MODO[modo], estado, rede_wifi_ok() ? "ok" : "--", rede_mqtt_ok() ? "ok" : "--");
rede_publicar(TOPICO_OLED, payload, -1);
}
static void publicar_framebuffer(void)
{
static char b64[1400]; // static: fora da pilha
size_t n = tela_base64(b64, sizeof(b64));
if (n == 0 || !rede_publicar(TOPICO_OLED_FB, b64, (int)n))
ESP_LOGD(TAG, "framebuffer não publicado");
}
No fim da task app, depois do switch, redesenhe quando tela_suja (como no fim do loop()).
Código completo do main.c até a T5 (clique para abrir)
// ELT73A - Lab 09 (T5): o firmware do Lab 08 migrado de framework = arduino para espidf.
// Mesmo circuito, mesmo contrato MQTT (tópicos e JSON), mesma tela. O que muda é a estrutura:
// setup() -> app_main(): inicia periféricos e cria a task da aplicação
// loop() + flags -> task "app" bloqueada numa FILA de eventos (xQueueReceive)
// Ticker -> esp_timer (o callback só põe um evento na fila)
// WiFi.h / PubSubClient -> esp_wifi + esp-mqtt, orientados a eventos (rede.c)
// Serial.printf -> ESP_LOGI / ESP_LOGW (com nível e etiqueta)
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "atuadores.h"
#include "config.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "gfx.h"
#include "nvs_flash.h"
#include "rede.h"
#include "sensores.h"
#include "tela.h"
static const char *TAG = "app";
// ------------------------------------------------------------------ eventos da fila
typedef enum {
EV_LER_DHT, // esp_timer do DHT22 (a cada intervalo)
EV_LER_ADC, // esp_timer do potenciômetro (10 Hz)
EV_MQTT_CONECTOU, // rede.c: (re)conectou ao broker
EV_REDE_MUDOU, // rede.c: Wi-Fi ou MQTT caiu/voltou (indicadores W/M)
EV_COMANDO, // rede.c: mensagem num tópico de comando
} tipo_evento_t;
typedef struct {
tipo_evento_t tipo;
char topico[64];
char texto[16];
} evento_t;
static QueueHandle_t fila;
static esp_timer_handle_t timer_dht, timer_adc;
// ------------------------------------------------------------------ estado (o mesmo do Lab 08)
typedef enum { MODO_POT, MODO_REMOTO, MODO_AUTO } modo_t;
static const char *NOME_MODO[] = {"pot", "remoto", "auto"};
static modo_t modo = MODO_POT;
static float intervalo_s = 5.0f;
static uint32_t seq;
static float ultima_t = NAN, ultima_h = NAN;
static bool tela_suja = true;
static int adc_raw, adc_mv;
static float setpoint = SP_MIN;
static int raw_publicado = -10000;
static int64_t t_adc_publicado;
static float aq_pct = -1, ve_pct = -1;
static float aq_remoto, ve_remoto;
static bool aquecendo;
static const char *estado = "---";
// ------------------------------------------------------------------ callbacks -> fila
// Rodam em outras tasks (esp_timer, esp-mqtt, event loop): só põem um evento na fila.
static void enfileirar(tipo_evento_t tipo)
{
evento_t ev = {.tipo = tipo};
if (xQueueSend(fila, &ev, 0) != pdTRUE) ESP_LOGW(TAG, "fila cheia: evento %d perdido", tipo);
}
static void ao_timer(void *arg) { enfileirar((tipo_evento_t)(intptr_t)arg); }
static void ao_conectar(void) { enfileirar(EV_MQTT_CONECTOU); }
static void ao_mudar(void) { enfileirar(EV_REDE_MUDOU); }
static void ao_receber(const char *topico, const char *texto)
{
evento_t ev = {.tipo = EV_COMANDO};
strlcpy(ev.topico, topico, sizeof(ev.topico));
strlcpy(ev.texto, texto, sizeof(ev.texto));
if (xQueueSend(fila, &ev, 0) != pdTRUE) ESP_LOGW(TAG, "fila cheia: comando perdido");
}
static void ler_adc(void)
{
sensores_ler_pot(&adc_raw, &adc_mv);
float sp = SP_MIN + adc_raw * (SP_MAX - SP_MIN) / 4095.0f;
setpoint = roundf(sp * 2) / 2; // passos de 0,5 °C
}
// ------------------------------------------------------------------ tela
static void indicador(int x, const char *letra, bool ok)
{
if (ok) {
gfx_retangulo_cheio(x, 0, 13, 9, GFX_BRANCO);
gfx_cor_texto(GFX_PRETO);
} else {
gfx_retangulo(x, 0, 13, 9, GFX_BRANCO);
gfx_cor_texto(GFX_BRANCO);
}
gfx_cursor(x + 4, 1);
gfx_texto(letra);
gfx_cor_texto(GFX_BRANCO);
}
static void barra(int y, const char *rotulo, float pct)
{
gfx_cursor(0, y);
gfx_texto(rotulo);
gfx_retangulo(16, y, 80, 8, GFX_BRANCO);
gfx_retangulo_cheio(18, y + 2, (int)(76 * pct / 100.0f), 4, GFX_BRANCO);
gfx_cursor(100, y);
gfx_printf("%3.0f%%", pct);
}
static void desenhar_tela(void)
{
gfx_limpar();
gfx_cor_texto(GFX_BRANCO);
gfx_tamanho_texto(1); // cabeçalho
gfx_cursor(0, 1);
gfx_texto("LAB09 grupo " GRUPO);
indicador(98, "W", rede_wifi_ok());
indicador(114, "M", rede_mqtt_ok());
gfx_linha_h(0, 11, GFX_W, GFX_BRANCO);
gfx_tamanho_texto(2); // temperatura medida
gfx_cursor(0, 15);
if (isnan(ultima_t)) gfx_texto("--.-");
else gfx_printf("%4.1f", ultima_t);
gfx_circulo(53, 17, 2, GFX_BRANCO);
gfx_cursor(58, 15);
gfx_texto("C");
gfx_tamanho_texto(1); // setpoint e ADC
gfx_cursor(76, 15);
gfx_printf("SP %4.1f", setpoint);
gfx_cursor(76, 24);
gfx_printf("%4d mV", adc_mv);
barra(35, "AQ", aq_pct < 0 ? 0 : aq_pct); // atuadores
barra(45, "VE", ve_pct < 0 ? 0 : ve_pct);
gfx_cursor(0, 56); // modo e estado
gfx_printf("%s: %s", NOME_MODO[modo], estado);
tela_enviar();
}
static void publicar_tela_texto(void)
{
char t[8] = "--.-";
if (!isnan(ultima_t)) snprintf(t, sizeof(t), "%.1f", ultima_t);
char payload[220];
snprintf(payload, sizeof(payload),
"{\"linhas\":[\"LAB09 grupo %s\",\"T: %s C SP: %.1f C\",\"AQ: %.0f %% VE: %.0f %%\","
"\"modo %s | %s\",\"WiFi %s | MQTT %s\"]}",
GRUPO, t, setpoint, aq_pct < 0 ? 0 : aq_pct, ve_pct < 0 ? 0 : ve_pct,
NOME_MODO[modo], estado, rede_wifi_ok() ? "ok" : "--", rede_mqtt_ok() ? "ok" : "--");
rede_publicar(TOPICO_OLED, payload, -1);
}
static void publicar_framebuffer(void)
{
static char b64[1400]; // static: fora da pilha
size_t n = tela_base64(b64, sizeof(b64));
if (n == 0 || !rede_publicar(TOPICO_OLED_FB, b64, (int)n))
ESP_LOGD(TAG, "framebuffer não publicado");
}
// ------------------------------------------------------------------ ADC e PWM no MQTT
static void publicar_adc(void)
{
char payload[96];
snprintf(payload, sizeof(payload), "{\"raw\":%d,\"mv\":%d,\"sp\":%.1f}", adc_raw, adc_mv, setpoint);
rede_publicar(TOPICO_ADC, payload, -1);
raw_publicado = adc_raw;
t_adc_publicado = esp_timer_get_time();
}
static void publicar_pwm(void)
{
char t[8] = "null";
if (!isnan(ultima_t)) snprintf(t, sizeof(t), "%.1f", ultima_t);
char payload[200];
snprintf(payload, sizeof(payload),
"{\"modo\":\"%s\",\"estado\":\"%s\",\"aq\":%.0f,\"ve\":%.0f,"
"\"aq_duty\":%lu,\"ve_duty\":%lu,\"sp\":%.1f,\"t\":%s}",
NOME_MODO[modo], estado, aq_pct, ve_pct,
(unsigned long)atuadores_duty(aq_pct), (unsigned long)atuadores_duty(ve_pct), setpoint, t);
rede_publicar(TOPICO_PWM, payload, -1);
ESP_LOGI(TAG, "[PWM] %s", payload);
}
// ------------------------------------------------------------------ decisão dos atuadores
static void controlar(void)
{
float aq = 0, ve = 0;
const char *novo_estado;
switch (modo) {
case MODO_POT: // potenciômetro = dimmer
aq = ve = adc_raw * 100.0f / 4095.0f;
novo_estado = "MANUAL";
break;
case MODO_REMOTO: // valores vindos do MQTT
aq = aq_remoto;
ve = ve_remoto;
novo_estado = "REMOTO";
break;
default: // ON/OFF com histerese
if (isnan(ultima_t)) {
novo_estado = "SEM DHT";
break;
}
if (ultima_t < setpoint - HISTERESE) aquecendo = true;
else if (ultima_t > setpoint + HISTERESE) aquecendo = false;
aq = aquecendo ? 100 : 0;
ve = fminf(fmaxf((ultima_t - setpoint - 1.0f) * 25.0f, 0.0f), 100.0f);
novo_estado = aquecendo ? "AQUECENDO" : (ultima_t > setpoint + 1.0f ? "RESFRIANDO" : "ESTAVEL");
break;
}
aq = roundf(aq);
ve = roundf(ve);
if (aq == aq_pct && ve == ve_pct && strcmp(novo_estado, estado) == 0) return; // nada mudou
aq_pct = aq;
ve_pct = ve;
estado = novo_estado;
atuadores_aplicar(aq_pct, ve_pct);
publicar_pwm();
tela_suja = true;
}
// ------------------------------------------------------------------ DHT22
static void ler_e_publicar(void)
{
float t, h;
if (!sensores_ler_dht(&t, &h)) return; // falha: descartada
seq++;
ultima_t = t;
ultima_h = h;
char payload[160];
snprintf(payload, sizeof(payload),
"{\"grupo\":\"%s\",\"seq\":%lu,\"t\":%.1f,\"h\":%.1f,\"uptime_ms\":%lu,\"intervalo_s\":%.1f}",
GRUPO, (unsigned long)seq, t, h, (unsigned long)(esp_timer_get_time() / 1000), intervalo_s);
bool ok = rede_publicar(TOPICO_DADOS, payload, -1);
ESP_LOGI(TAG, "[PUB] %s %s -> %s", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
controlar(); // no modo auto a temperatura decide
tela_suja = true;
}
// ------------------------------------------------------------------ comandos
static void tratar_comando(const char *topico, const char *txt)
{
ESP_LOGI(TAG, "[CMD] %s <- '%s'", topico, txt);
if (strcmp(topico, TOPICO_INTERVALO) == 0) {
char *fim;
float v = strtof(txt, &fim);
if (fim == txt || v < 2.0f || v > 60.0f) {
ESP_LOGW(TAG, "[CMD] intervalo fora de 2..60 s - ignorado");
return;
}
intervalo_s = v;
esp_timer_stop(timer_dht); // o "detach() + attach()"
esp_timer_start_periodic(timer_dht, (uint64_t)(intervalo_s * 1e6f));
tela_suja = true;
} else if (strcmp(topico, TOPICO_CMD_MODO) == 0) {
int novo = -1;
for (int i = 0; i < 3; i++)
if (strcasecmp(txt, NOME_MODO[i]) == 0) novo = i;
if (novo < 0) {
ESP_LOGW(TAG, "[CMD] modo invalido (use pot, remoto ou auto)");
return;
}
modo = (modo_t)novo;
aquecendo = false;
controlar();
tela_suja = true;
} else if (strcmp(topico, TOPICO_CMD_AQ) == 0 || strcmp(topico, TOPICO_CMD_VE) == 0) {
char *fim;
float v = strtof(txt, &fim);
if (fim == txt || v < 0 || v > 100) {
ESP_LOGW(TAG, "[CMD] use 0..100 (%%)");
return;
}
if (strcmp(topico, TOPICO_CMD_AQ) == 0) aq_remoto = v;
else ve_remoto = v;
if (modo == MODO_REMOTO) controlar();
else ESP_LOGI(TAG, "[CMD] guardado; vale no modo remoto");
}
}
// ------------------------------------------------------------------ task da aplicação
// É o antigo loop(): mas em vez de girar o tempo todo perguntando "tem algo?", ela DORME na fila
// e só acorda quando chega um evento. Todo o estado é mexido só aqui: sem disputa entre tasks.
static void task_app(void *arg)
{
evento_t ev;
for (;;) {
if (xQueueReceive(fila, &ev, portMAX_DELAY) != pdTRUE) continue;
switch (ev.tipo) {
case EV_LER_ADC:
ler_adc();
if (abs(adc_raw - raw_publicado) > ADC_BANDA) { // banda morta
ESP_LOGI(TAG, "[ADC] raw=%4d %4d mV SP=%.1f C", adc_raw, adc_mv, setpoint);
publicar_adc();
controlar();
tela_suja = true;
} else if (esp_timer_get_time() - t_adc_publicado >= ADC_REPUB_US) {
publicar_adc(); // "ainda estou aqui"
}
break;
case EV_LER_DHT:
ler_e_publicar();
break;
case EV_MQTT_CONECTOU:
publicar_adc(); // estado atual para quem
publicar_pwm(); // acabou de chegar
tela_suja = true;
break;
case EV_REDE_MUDOU:
tela_suja = true;
break;
case EV_COMANDO:
tratar_comando(ev.topico, ev.texto);
break;
}
if (tela_suja) {
tela_suja = false;
desenhar_tela();
publicar_tela_texto();
publicar_framebuffer();
}
}
}
static esp_timer_handle_t criar_timer(const char *nome, tipo_evento_t tipo)
{
esp_timer_handle_t t;
esp_timer_create_args_t args = {
.callback = ao_timer,
.arg = (void *)(intptr_t)tipo,
.name = nome,
};
ESP_ERROR_CHECK(esp_timer_create(&args, &t));
return t;
}
void app_main(void)
{
ESP_LOGI(TAG, "=== Lab 09 - ESP-IDF: ADC + PWM + MQTT ===");
// NVS: o Wi-Fi guarda a calibração do rádio nela
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
ESP_ERROR_CHECK(esp_event_loop_create_default());
sensores_iniciar();
atuadores_iniciar();
ler_adc();
controlar();
tela_iniciar();
desenhar_tela();
fila = xQueueCreate(16, sizeof(evento_t));
timer_dht = criar_timer("dht", EV_LER_DHT);
timer_adc = criar_timer("adc", EV_LER_ADC);
// a task da aplicação na CPU 1; o Wi-Fi fica na CPU 0 (o DHT22 desliga interrupções ~5 ms)
xTaskCreatePinnedToCore(task_app, "app", 6144, NULL, 5, NULL, 1);
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
static char client_id[32];
snprintf(client_id, sizeof(client_id), "lab09-%s-%02X%02X", GRUPO, mac[4], mac[5]);
rede_callbacks_t cb = {.ao_conectar = ao_conectar, .ao_mudar = ao_mudar, .ao_receber = ao_receber};
rede_iniciar(client_id, &cb);
esp_timer_start_periodic(timer_dht, (uint64_t)(intervalo_s * 1e6f));
esp_timer_start_periodic(timer_adc, 100 * 1000); // 10 Hz
// app_main pode terminar: a task "app", os timers e o Wi-Fi continuam rodando
}
5.3 O Node-RED não pode perceber a troca
No Node-RED, exporte a aba Lab 08 (menu → Export → Current flow), troque lab08 por
lab09 no texto (tópicos, nome da aba, caminho /lab08 do dashboard e o banco
lab08.sqlite) e importe como uma aba nova. Sem mudar mais nada:
- o banco
lab09.sqliterecebe as leituras e as mudanças de PWM; - as consultas do Lab 08 (falhas na sequência, tempo em cada estado, energia) funcionam;
- o dashboard
/lab09mostra o histórico.
Para a réplica pixel a pixel da tela (a evidência t5-oled.png), faça o mesmo com a aba Lab 07:
exporte, troque lab07 por lab09 e importe. O framebuffer chega em .../oled/fb, como antes.
P5 (parte 1): (a) o esp_lcd inicia o SSD1306 sem espelhar a imagem, e a Adafruit espelha nos dois
eixos (0xA1, 0xC8). O que você veria no Wokwi sem a linha esp_lcd_panel_mirror(painel, true, true)? Teste. (b) O app desta versão tem ~960 KB. A partição padrão do ESP-IDF para o app
é de 1 MB. Por que o sdkconfig.defaults troca para SINGLE_APP_LARGE (1,5 MB), e que
mensagem o build daria se você não trocasse e o código crescesse um pouco?
Evidências: em evidencias/t5-oled.png, o Wokwi e o framebuffer no dashboard (Lab 07) lado a
lado, com a mesma tela; em evidencias/t5-nodered.png, o dashboard /lab09 (cópia do Lab 08)
com o histórico vindo do banco.
- ├── 📂src
- ├── 📄tela.h👈 Criar Aqui
- ├── 📄tela.c👈 Criar Aqui
- └── 📄main.c👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t5-oled.png👈 Criar Aqui
- └── 📄t5-nodered.png👈 Criar Aqui
git conferir src/tela.h src/tela.c src/main.c evidencias/t5-oled.png evidencias/t5-nodered.png
Tela e o Node-RED do Lab 08
git conferir src/tela.h src/tela.c src/main.c evidencias/t5-oled.png evidencias/t5-nodered.png
git add src/tela.h src/tela.c src/main.c evidencias/t5-oled.png evidencias/t5-nodered.png && git commit -m "T5: Tela e o Node-RED do Lab 08" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T5.
Projeto integrador — NVS, diagnóstico e comparação
Hoje, se o ESP32 reiniciar no modo auto com intervalo de 10 s, ele volta em pot com 5 s: o
estado só existe na RAM. E ninguém de fora sabe quanta memória sobra, nem se a task tem pilha
suficiente.
Requisitos
-
NVS. Guardar o
modoe ointervalona NVS (namespacelab09) a cada comando aceito, e carregá-los no boot, antes de aplicar o primeiro PWM e de iniciar o timer do DHT22.modocomou8;intervalocomou16em décimos de segundo (10 s → 100);- valide o que leu (modo 0..2, intervalo 2..60 s): a flash pode ter lixo de outra versão.
-
Diagnóstico. Um terceiro
esp_timer(30 s) gera o eventoEV_DIAG, e a taskapppublica em.../diag:elt73a/lab09/grupo-x/diag (valores ilustrativos){"uptime_s":61,"heap_livre":231412,"heap_minimo":219808,"pilha_livre_app":4928,"rssi":-62,"reset":1}Campo De onde vem heap_livre,heap_minimoesp_get_free_heap_size(),esp_get_minimum_free_heap_size()pilha_livre_appuxTaskGetStackHighWaterMark(NULL): no ESP-IDF, em bytesrssiesp_wifi_sta_get_ap_info()(userede_rssi())resetesp_reset_reason()(1 = ligou, 3 =esp_restart(), …) -
Teste de reset. Mande
cmd/modo autoecmd/intervalo 10, reinicie a simulação e mostre no serial que o ESP32 voltou emautocom 10 s. -
Comparação. Em
evidencias/t6-comparacao.md, uma tabela Lab 08 (Arduino) × Lab 09 (ESP-IDF) com: tamanho do app (dopio run), RAM estática (RAM:dopio run), heap livre depois de conectar (Lab 09: o.../diag; Lab 08: acrescenteSerial.printf("heap %u\n", ESP.getFreeHeap());no fim dosetup()), linhas de código (src/menos os componentes) e o tempo do boot atéMQTT conectado. Termine com um parágrafo: o que ficou melhor, o que ficou pior e quando você escolheria cada framework.
Saída esperada (segundo boot, depois dos comandos):
I (360) app: === Lab 09 - ESP-IDF: ADC + PWM + MQTT ===
I (372) app: NVS: modo auto, intervalo 10.0 s
I (420) atuadores: timer 0: 5 Hz pedidos, 5 Hz obtidos
I (425) atuadores: timer 1: 25000 Hz pedidos, 25000 Hz obtidos
I (431) app: [PWM] {"modo":"auto","estado":"SEM DHT","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":37.5,"t":null}
Dicas de API
#include "nvs.h"
nvs_handle_t h;
if (nvs_open("lab09", NVS_READWRITE, &h) == ESP_OK) {
nvs_set_u8(h, "modo", (uint8_t)modo);
nvs_set_u16(h, "intervalo", (uint16_t)lroundf(intervalo_s * 10));
nvs_commit(h); // sem o commit, nada vai para a flash
nvs_close(h);
}
// leitura: nvs_open(..., NVS_READONLY, &h) e nvs_get_u8 / nvs_get_u16;
// na primeira vez o namespace não existe e nvs_open devolve erro: use os valores padrão
// diagnóstico (na task app, no evento EV_DIAG):
// esp_get_free_heap_size(), esp_get_minimum_free_heap_size(),
// uxTaskGetStackHighWaterMark(NULL), rede_rssi(), esp_reset_reason()
P5 (parte 2): (a) a task app foi criada com 6144 bytes de pilha. Quanto ela usa de verdade
(veja pilha_livre_app)? O que aconteceria com 2048? (b) heap_minimo é menor que heap_livre.
O que ele mede, e por que é ele que importa para saber se a memória vai acabar? (c) A NVS grava na
flash a cada comando. A flash aguenta ~100 mil apagamentos por setor. É um problema gravar a cada
cmd/intervalo? E se fosse a cada leitura do DHT22?
- ├── 📂src
- ├── 📄config.h👈 Edite Aqui
- └── 📄main.c👈 Edite Aqui
- ├── 📂evidencias
- ├── 📄t6-serial.txt👈 Criar Aqui
- └── 📝t6-comparacao.md👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir src/config.h src/main.c evidencias/t6-serial.txt evidencias/t6-comparacao.md README.md
NVS, diagnostico e comparacao
git conferir src/config.h src/main.c evidencias/t6-serial.txt evidencias/t6-comparacao.md README.md
git add src/config.h src/main.c evidencias/t6-serial.txt evidencias/t6-comparacao.md README.md && git commit -m "T6: NVS, diagnostico e comparacao" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.
Logout do seu ambiente dev, git e gh
Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.
1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:
(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email
Para conferir, este comando não deve mostrar nada:
cmdkey /list | findstr /i github
2. Pare os containers do lab:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
3. No navegador, saia da sua conta em github.com e feche todas as janelas.