Laboratório 07
Checklist — ADC, PWM, modos de operação e controle ON/OFF
-
diagram.jsoncom potenciômetro no GPIO34 e LEDs "aquecedor" (GPIO25) e "ventilador" (GPIO26) com resistores, mais o analisador lógico (T1) - ADC: média de 16 amostras, leitura em mV e setpoint de 20 a 55 °C em passos de 0,5 °C (T2)
- PWM (LEDC): dois canais de 8 bits, a 5 Hz e 25 kHz, com o potenciômetro como dimmer (T3)
- MQTT:
.../adccom banda morta,.../pwma cada mudança e comandos.../cmd/modo,.../cmd/aquecedor,.../cmd/ventilador(T4) - Node-RED: tabela
atuacaono SQLite, consultas comLEAD()e dashboard com modo e sliders (T5) - Modo
auto: aquecedor ON/OFF com histerese e ventilador proporcional (T6) - Previsões P1–P4 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 15 · T3 20 · T4 20 · 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
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: ELT85B - IoT Industrial.
- 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%\ELT85BN21\lab07-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-a"
2. Gere o LAB IoT do grupo em docker\lab07-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-a-nodered && (del /q "data\lab07-a\flows.json" "data\lab07-a\flows_cred.json" "data\lab07-a\.flows*.backup" 2>nul & docker compose start lab07-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-b"
2. Gere o LAB IoT do grupo em docker\lab07-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-b-nodered && (del /q "data\lab07-b\flows.json" "data\lab07-b\flows_cred.json" "data\lab07-b\.flows*.backup" 2>nul & docker compose start lab07-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-c"
2. Gere o LAB IoT do grupo em docker\lab07-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-c-nodered && (del /q "data\lab07-c\flows.json" "data\lab07-c\flows_cred.json" "data\lab07-c\.flows*.backup" 2>nul & docker compose start lab07-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-d"
2. Gere o LAB IoT do grupo em docker\lab07-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-d-nodered && (del /q "data\lab07-d\flows.json" "data\lab07-d\flows_cred.json" "data\lab07-d\.flows*.backup" 2>nul & docker compose start lab07-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-e"
2. Gere o LAB IoT do grupo em docker\lab07-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-e-nodered && (del /q "data\lab07-e\flows.json" "data\lab07-e\flows_cred.json" "data\lab07-e\.flows*.backup" 2>nul & docker compose start lab07-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-f"
2. Gere o LAB IoT do grupo em docker\lab07-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-f-nodered && (del /q "data\lab07-f\flows.json" "data\lab07-f\flows_cred.json" "data\lab07-f\.flows*.backup" 2>nul & docker compose start lab07-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-g"
2. Gere o LAB IoT do grupo em docker\lab07-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-g-nodered && (del /q "data\lab07-g\flows.json" "data\lab07-g\flows_cred.json" "data\lab07-g\.flows*.backup" 2>nul & docker compose start lab07-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-h"
2. Gere o LAB IoT do grupo em docker\lab07-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-h-nodered && (del /q "data\lab07-h\flows.json" "data\lab07-h\flows_cred.json" "data\lab07-h\.flows*.backup" 2>nul & docker compose start lab07-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-i"
2. Gere o LAB IoT do grupo em docker\lab07-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-i-nodered && (del /q "data\lab07-i\flows.json" "data\lab07-i\flows_cred.json" "data\lab07-i\.flows*.backup" 2>nul & docker compose start lab07-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-j"
2. Gere o LAB IoT do grupo em docker\lab07-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-j-nodered && (del /q "data\lab07-j\flows.json" "data\lab07-j\flows_cred.json" "data\lab07-j\.flows*.backup" 2>nul & docker compose start lab07-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-k"
2. Gere o LAB IoT do grupo em docker\lab07-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-k-nodered && (del /q "data\lab07-k\flows.json" "data\lab07-k\flows_cred.json" "data\lab07-k\.flows*.backup" 2>nul & docker compose start lab07-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-l"
2. Gere o LAB IoT do grupo em docker\lab07-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-l-nodered && (del /q "data\lab07-l\flows.json" "data\lab07-l\flows_cred.json" "data\lab07-l\.flows*.backup" 2>nul & docker compose start lab07-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-m"
2. Gere o LAB IoT do grupo em docker\lab07-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-m-nodered && (del /q "data\lab07-m\flows.json" "data\lab07-m\flows_cred.json" "data\lab07-m\.flows*.backup" 2>nul & docker compose start lab07-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab07-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab07-x"
2. Gere o LAB IoT do grupo em docker\lab07-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab07 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --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 lab07-x-nodered && (del /q "data\lab07-x\flows.json" "data\lab07-x\flows_cred.json" "data\lab07-x\.flows*.backup" 2>nul & docker compose start lab07-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Esta aula continua o Lab 06. Até agora o ESP32 só lia o mundo, com o DHT22 (digital). Agora ele passa a ler uma grandeza analógica, a posição de um potenciômetro, pelo ADC. E passa também a agir: dois canais de PWM acionam um "aquecedor" e um "ventilador", representados por LEDs. Com MQTT, Node-RED e SQLite, o nó vira o embrião de uma câmara climática: o potenciômetro define o setpoint, e o ESP32 liga o aquecedor quando a temperatura está abaixo dele.
Objetivos
- Ler um sinal analógico com o ADC do ESP32: resolução (12 bits), atenuação, leitura em milivolts calibrada e por que o potenciômetro precisa estar num pino do ADC1.
- Reduzir o ruído com média de amostras e não inundar o broker com uma banda morta.
- Gerar PWM com o periférico LEDC: canal, frequência, resolução e duty cycle, e a troca entre frequência e resolução.
- Organizar o firmware em modos de operação (
pot,remoto,auto) comandados por MQTT. - No Node-RED, registrar cada mudança dos atuadores no SQLite e calcular tempo em cada
estado e energia com a função de janela
LEAD(). - (Integrador) Implementar um controle ON/OFF com histerese.
Material
- VS Code + PlatformIO + extensão Wokwi (ESP32 simulado).
- O LAB IoT do
lab07-x(gerado pelogen_iot_aluno.py): Node-RED comnode-red-node-sqlitee o Dashboard 2.0. - Nenhuma biblioteca nova: o ADC e o LEDC fazem parte do core Arduino do ESP32. O
platformio.inié o mesmo do Lab 06.
O Wokwi simula o ADC (o potenciômetro gira de verdade), o LEDC (o brilho do LED acompanha o duty) e um analisador lógico para medir o PWM. Mas o ADC simulado é ideal: linear e sem ruído. Numa placa física, a média de amostras e a banda morta da T2/T4 fazem diferença visível. E o "aquecedor" não esquenta o DHT22: na T6, você faz o papel da planta, mexendo no slider do sensor.
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/ELT85B-N21-2026-2/lab07-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-a/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-a.git && cd lab07-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-b/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-b.git && cd lab07-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-c/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-c.git && cd lab07-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-d/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-d.git && cd lab07-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-e/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-e.git && cd lab07-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-f/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-f.git && cd lab07-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-g/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-g.git && cd lab07-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-h/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-h.git && cd lab07-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-i/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-i.git && cd lab07-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-j/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-j.git && cd lab07-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-k/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-k.git && cd lab07-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-l/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-l.git && cd lab07-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-m/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-m.git && cd lab07-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-x/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-x.git && cd lab07-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-p/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-p.git && cd lab07-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab07-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab07-grupo-n/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab07-grupo-n.git && cd lab07-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab07-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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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 07:
- 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.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Circuito: potenciômetro, LEDs e analisador lógico · 10 pts
- T2 — Leitura do potenciômetro com o ADC · 15 pts
- T3 — PWM com o LEDC · 20 pts
- T4 — ADC e PWM no MQTT, modos pot e remoto · 20 pts
- T5 — Node-RED: SQLite e dashboard de comando · 15 pts
- T6 — Modo auto: controle ON/OFF com histerese · 20 pts
O repositório do grupo nasce do lab07-template, que já traz o firmware final do Lab 06
(com o framebuffer) em src/main.cpp:
Estrutura de Arquivos do Projeto
- ├── 🔧platformio.ini👈 Verificar
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 🔧diagram.json👈 Edite Aqui
- ├── 🔧wokwi.toml👈 Verificar
- ├── 📄.gitignore👈 Verificar
- ├── 📂.vscode
- └── 🔧extensions.json👈 Verificar
- ├── 📂nodered
- └── 🔧flows-lab07.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t2-serial.txt👈 Criar Aqui
- ├── 📄t3-pwm.png👈 Criar Aqui
- ├── 📄t4-mqtt.txt👈 Criar Aqui
- ├── 📄t5-sqlite.txt👈 Criar Aqui
- ├── 📄t5-dashboard.png👈 Criar Aqui
- ├── 📄t6-serial.txt👈 Criar Aqui
- └── 📄t6-sqlite.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Tudo fica sob elt85b/lab07/grupo-X/. Troque o X (e o #define GRUPO) pela letra do seu
grupo. dht, status, oled, oled/fb e cmd/intervalo continuam como no Lab 06.
| Tópico | Sentido | Payload |
|---|---|---|
.../adc | ESP32 → broker | {"raw":2048,"mv":1650,"sp":37.5} |
.../pwm | ESP32 → broker | {"modo":"auto","estado":"AQUECENDO","aq":100,"ve":0,"aq_duty":255,"ve_duty":0,"sp":37.5,"t":24.5} |
.../cmd/modo | broker → ESP32 | pot, remoto ou auto (T6) |
.../cmd/aquecedor | broker → ESP32 | 0 a 100 (%), vale no modo remoto |
.../cmd/ventilador | broker → ESP32 | 0 a 100 (%), vale no modo remoto |
Parte 1 — Circuito
Acrescente ao circuito do Lab 06:
- Potenciômetro (
wokwi-potentiometer):VCC → 3V3,GND → GND,SIG → GPIO34. - LED laranja "aquecedor" no GPIO25 e LED azul "ventilador" no GPIO26, cada um com um resistor de 220 Ω em série (o GPIO fornece no máximo ~40 mA; o resistor limita a corrente do LED a ~6 mA).
- Analisador lógico (
wokwi-logic-analyzer):D0 → GPIO25,D1 → GPIO26,GND → GND. Ele grava os dois sinais de PWM para você medir frequência e duty na T3.
- └── 🔧diagram.json👈 Edite Aqui
git conferir diagram.json
{
"version": 1,
"author": "ELT85B - Lab 07",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-dht22",
"id": "dht1",
"top": -76.5,
"left": 157.8,
"attrs": { "temperature": "24.5", "humidity": "55" }
},
{
"type": "board-ssd1306",
"id": "oled1",
"top": 108.74,
"left": 172.23,
"attrs": { "i2cAddress": "0x3c" }
},
{
"type": "wokwi-potentiometer",
"id": "pot1",
"top": 30,
"left": -150,
"attrs": { "value": "511" }
},
{
"type": "wokwi-resistor",
"id": "r1",
"top": 215,
"left": 120,
"attrs": { "value": "220" }
},
{
"type": "wokwi-led",
"id": "led_aq",
"top": 170,
"left": 230,
"attrs": { "color": "orange", "label": "aquecedor" }
},
{
"type": "wokwi-resistor",
"id": "r2",
"top": 265,
"left": 120,
"attrs": { "value": "220" }
},
{
"type": "wokwi-led",
"id": "led_ve",
"top": 220,
"left": 300,
"attrs": { "color": "blue", "label": "ventilador" }
},
{
"type": "wokwi-logic-analyzer",
"id": "logic1",
"top": 320,
"left": 120,
"attrs": { "filename": "lab07-pwm" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["dht1:VCC", "esp:3V3", "red", []],
["dht1:GND", "esp:GND.2", "black", []],
["dht1:SDA", "esp:15", "green", []],
["oled1:VCC", "esp:3V3", "red", []],
["oled1:GND", "esp:GND.2", "black", []],
["oled1:SDA", "esp:21", "blue", []],
["oled1:SCL", "esp:22", "purple", []],
["pot1:VCC", "esp:3V3", "red", []],
["pot1:GND", "esp:GND.2", "black", []],
["pot1:SIG", "esp:34", "orange", []],
["esp:25", "r1:1", "orange", []],
["r1:2", "led_aq:A", "orange", []],
["led_aq:C", "esp:GND.2", "black", []],
["esp:26", "r2:1", "blue", []],
["r2:2", "led_ve:A", "blue", []],
["led_ve:C", "esp:GND.2", "black", []],
["logic1:D0", "esp:25", "orange", []],
["logic1:D1", "esp:26", "blue", []],
["logic1:GND", "esp:GND.2", "black", []]
],
"dependencies": {}
}
O ESP32 tem dois ADCs. O ADC2 (GPIOs 0, 2, 4, 12–15 e 25–27) é usado pelo rádio
Wi-Fi: com o Wi-Fi ligado, analogRead() num pino do ADC2 falha. Por isso o potenciômetro
vai num pino do ADC1 (GPIOs 32–39). O GPIO34 é somente entrada, sem pull-up interno,
o que é perfeito para um sinal analógico.
Circuito: potenciômetro, LEDs e analisador lógico
git conferir diagram.json
git add diagram.json && git commit -m "T1: Circuito: potenciômetro, LEDs e analisador lógico" && 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 — ADC: lendo o potenciômetro
2.1 Como o ADC do ESP32 enxerga uma tensão
O ADC é do tipo SAR, de 12 bits: converte a tensão do pino num número de 0 a 4095. Três detalhes importam:
- Atenuação. O conversor só mede ~1,1 V internamente. Para medir até perto de 3,3 V, o
sinal passa por um atenuador. Com
ADC_11db, a faixa vai de ~0 a ~3,1 V. A Espressif recomenda usar só até ~2,45 V se precisar de linearidade. - Calibração.
analogRead()devolve o número cru.analogReadMilliVolts()usa a calibração gravada de fábrica no chip (eFuse) e devolve milivolts: é ela que você usa quando o valor tem significado físico. - Ruído. Numa placa real, leituras seguidas do mesmo potenciômetro parado variam algumas dezenas de unidades. Uma média de 16 amostras reduz esse ruído para ~1/4.
O potenciômetro vira o setpoint da câmara, de 20 a 55 °C em passos de 0,5 °C:
setpoint = 20 + raw × (55 − 20) / 4095 → arredondado para 0,5 °C
raw = 0 → 20,0 °C
raw = 2048 → 37,5 °C
raw = 4095 → 55,0 °C
2.2 Código
A leitura é disparada por um segundo Ticker, a 10 Hz, com o mesmo padrão de flag do
Lab 05: o callback só marca adcPendente, e o loop() lê.
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
// ---- ADC: potenciômetro no GPIO34 (ADC1_CH6 - o ADC1 funciona junto com o Wi-Fi)
#define POT_PIN 34
#define ADC_AMOSTRAS 16 // média de 16 leituras (reduz o ruído)
#define ADC_BANDA 40 // só reage se mudar mais que ~1 % (40/4095)
#define SP_MIN 20.0f // faixa do setpoint (°C)
#define SP_MAX 55.0f
Ticker temporizadorAdc; // leitura do potenciômetro
volatile bool adcPendente = false;
int adcRaw = 0, adcMv = 0; // média das leituras
float setpoint = SP_MIN; // °C, vem do potenciômetro
int rawPublicado = -10000; // último raw "aceito" (banda morta)
void aoEstourarTemporizadorAdc() { adcPendente = true; }
void lerAdc() {
uint32_t somaRaw = 0, somaMv = 0;
for (int i = 0; i < ADC_AMOSTRAS; i++) {
somaRaw += analogRead(POT_PIN);
somaMv += analogReadMilliVolts(POT_PIN);
}
adcRaw = somaRaw / ADC_AMOSTRAS;
adcMv = somaMv / ADC_AMOSTRAS;
float sp = SP_MIN + adcRaw * (SP_MAX - SP_MIN) / 4095.0f;
setpoint = roundf(sp * 2) / 2; // passos de 0,5 °C
}
// em setup(), depois de dht.begin():
// analogReadResolution(12); // 0..4095
// analogSetPinAttenuation(POT_PIN, ADC_11db); // faixa de ~0 a 3,1 V
// lerAdc();
// ... e no fim do setup():
// temporizadorAdc.attach_ms(100, aoEstourarTemporizadorAdc); // 10 Hz
//
// no loop():
// if (adcPendente) {
// adcPendente = false;
// lerAdc();
// if (abs(adcRaw - rawPublicado) > ADC_BANDA) { // banda morta: ignora o ruído
// rawPublicado = adcRaw;
// Serial.printf("[ADC] raw=%4d %4d mV SP=%.1f C\r\n", adcRaw, adcMv, setpoint);
// telaSuja = true;
// }
// }
Na tela, mostre o SP e os mV à direita da temperatura. O desenho final, com as barras
de PWM que entram na T3, está no código completo da T4:
LAB07 grupo a [W] [M]
-------------------------------
24.5 °C SP 37.5
1650 mV
AQ [██████████ ] 50%
VE [██████████ ] 50%
pot: MANUAL
Gire o potenciômetro no Wokwi e veja o serial:
=== Lab 07 - ADC + PWM + MQTT ===
[ADC] raw=2047 1650 mV SP=37.5 C
[ADC] raw=3001 2420 mV SP=45.5 C
[ADC] raw=1200 968 mV SP=30.5 C
Os valores em mV dependem da calibração e podem variar um pouco no seu simulador.
- P1: troque o
POT_PINpara GPIO4 (que é do ADC2), religue o fio e rode com o Wi-Fi conectado. O queanalogRead()devolve? E se você comentar oconectarWiFi()? Depois volte para o GPIO34. Por que, num pino de ADC, um potenciômetro precisa de VCC e GND, e não só do fio de sinal?
Anote as previsões e o que observou no README.md.
Evidência: salve o serial girando o potenciômetro de um extremo ao outro (pelo menos 5
linhas [ADC]) em evidencias/t2-serial.txt.
- └── 📂evidencias
- └── 📄t2-serial.txt👈 Criar Aqui
git conferir evidencias/t2-serial.txt
Leitura do potenciômetro com o ADC
git conferir src/main.cpp evidencias/t2-serial.txt
git add src/main.cpp evidencias/t2-serial.txt && git commit -m "T2: Leitura do potenciômetro com o ADC" && 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 — PWM com o LEDC
3.1 O que é o PWM e como o LEDC gera
Um pino digital só fica em 0 V ou 3,3 V. O PWM liga e desliga esse pino muito rápido, e a fração do tempo ligado (o duty cycle) controla a potência média entregue à carga:
duty 64 (25 %) ▇▁▁▁▇▁▁▁▇▁▁▁ potência média = 25 %
duty 191 (75 %) ▇▇▇▁▇▇▇▁▇▇▇▁ potência média = 75 %
|<-T->| frequência = 1/T
No ESP32 quem gera o PWM é o periférico LEDC: 16 canais, cada um com frequência e resolução (bits do duty) próprias, ligados a qualquer GPIO de saída. O PWM roda em hardware: depois de configurado, não ocupa a CPU.
Frequência e resolução disputam o mesmo relógio de 80 MHz:
frequência máxima = 80 MHz / 2^bits
8 bits (0..255) → até 312,5 kHz
10 bits (0..1023) → até 78,1 kHz
12 bits (0..4095) → até 19,5 kHz ← não serve para 25 kHz!
Usamos frequências bem diferentes nos dois canais, de propósito:
| Canal | Pino | Carga real (na câmara) | Frequência | Por quê |
|---|---|---|---|---|
| 0 | GPIO25 | resistência via relé de estado sólido / MOSFET | 5 Hz | a resistência tem inércia térmica de segundos; chavear devagar reduz perdas e interferência |
| 1 | GPIO26 | ventoinha de 4 fios | 25 kHz | é o padrão das ventoinhas PWM: acima da faixa audível, sem zumbido |
3.2 A API mudou entre as versões do core
O PlatformIO usa hoje o core Arduino 2.x. O core 3.x, usado pela Arduino IDE recente, mudou as funções do LEDC. Para o mesmo código compilar nos dois, encapsule:
| Core 2.x | Core 3.x |
|---|---|
ledcSetup(canal, freq, bits) | ledcAttachChannel(pino, freq, bits, canal) |
ledcAttachPin(pino, canal) | (feito pela linha acima) |
ledcWrite(canal, duty) | ledcWrite(pino, duty) |
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
// ---- PWM (LEDC): dois canais com frequências bem diferentes
#define AQ_PIN 25 // "aquecedor": resistência -> PWM lento
#define VE_PIN 26 // "ventilador": ventoinha 4 fios -> 25 kHz
#define AQ_CANAL 0
#define VE_CANAL 1
#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)
float aqPct = -1, vePct = -1; // % aplicados (-1: ainda não aplicado)
const char *estado = "---";
void pwmIniciar(uint8_t pino, uint8_t canal, uint32_t freq) {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
ledcAttachChannel(pino, freq, PWM_BITS, canal);
#else
ledcSetup(canal, freq, PWM_BITS);
ledcAttachPin(pino, canal);
#endif
}
void pwmEscrever(uint8_t pino, uint8_t canal, uint32_t duty) {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
(void)canal;
ledcWrite(pino, duty); // 3.x: endereça pelo pino
#else
(void)pino;
ledcWrite(canal, duty); // 2.x: endereça pelo canal
#endif
}
uint32_t dutyDe(float pct) { return (uint32_t)lroundf(pct * PWM_MAX / 100.0f); }
// Decide os atuadores. Na T3 só existe o modo "potenciômetro = dimmer".
void controlar() {
float aq = roundf(adcRaw * 100.0f / 4095.0f);
float ve = aq;
if (aq == aqPct && ve == vePct) return; // nada mudou: não reescreve
aqPct = aq;
vePct = ve;
estado = "MANUAL";
pwmEscrever(AQ_PIN, AQ_CANAL, dutyDe(aqPct));
pwmEscrever(VE_PIN, VE_CANAL, dutyDe(vePct));
Serial.printf("[PWM] aq=%.0f%% (duty %lu) ve=%.0f%% (duty %lu)\r\n",
aqPct, (unsigned long)dutyDe(aqPct), vePct, (unsigned long)dutyDe(vePct));
telaSuja = true;
}
// em setup(), antes de lerAdc():
// pwmIniciar(AQ_PIN, AQ_CANAL, AQ_FREQ_HZ);
// pwmIniciar(VE_PIN, VE_CANAL, VE_FREQ_HZ);
// ... e depois de lerAdc(): controlar();
//
// no loop(), dentro do if da banda morta do ADC: controlar();
Gire o potenciômetro e observe os dois LEDs: o azul muda de brilho suavemente, e o laranja pisca 5 vezes por segundo, com o tempo aceso proporcional ao duty.
3.3 Medindo com o analisador lógico
Deixe o potenciômetro em ~25 %, rode a simulação por alguns segundos e pare. No VS Code o
Wokwi grava a captura do analisador num arquivo .vcd na pasta do projeto
(dir /s /b *.vcd mostra onde). Abra-o no PulseView ou no
Surfer (app.surfer-project.org, no navegador) e meça:
- D0 (aquecedor): período ≈ 200 ms (5 Hz), tempo em nível alto ≈ 25 % do período.
- D1 (ventilador): período ≈ 40 µs (25 kHz), mesmo duty. Dê zoom: em escala de milissegundos ele parece um "borrão".
P2: por que o LED do aquecedor pisca e o do ventilador não, se os dois recebem o mesmo duty? O que aconteceria numa ventoinha real acionada a 5 Hz? E numa resistência acionada por um relé de estado sólido a 25 kHz? Qual a maior resolução possível a 25 kHz?
Evidência: captura do PulseView ou do Surfer com os dois canais e as medições, em
evidencias/t3-pwm.png.
- └── 📂evidencias
- └── 📄t3-pwm.png👈 Criar Aqui
git conferir evidencias/t3-pwm.png
PWM com o LEDC
git conferir src/main.cpp evidencias/t3-pwm.png
git add src/main.cpp evidencias/t3-pwm.png && git commit -m "T3: PWM com o LEDC" && 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 — ADC e PWM no MQTT, modos pot e remoto
Agora os atuadores podem ser comandados de fora. O firmware ganha modos de operação:
| Modo | Quem decide o PWM | O potenciômetro é... |
|---|---|---|
pot | o potenciômetro (dimmer, como na T3) | o comando dos dois canais |
remoto | os comandos .../cmd/aquecedor e .../cmd/ventilador | só o setpoint (exibido) |
auto | o controle ON/OFF (T6) | o setpoint da câmara |
4.1 O que muda
controlar()passa a olhar omodo. Ele só mexe no PWM, e só publica em.../pwm, quando algo mudou: o broker recebe um evento por mudança, não um fluxo constante..../adcé publicado quando a leitura sai da banda morta (±40 contagens) ou a cada 10 s, como sinal de "ainda estou aqui" para quem acabou de abrir o dashboard.- Comandos:
cmd/modoaceita sópotouremoto(oautoentra na T6);cmd/aquecedorecmd/ventiladoraceitam 0–100 e ficam guardados até o modo serremoto. - Ao (re)conectar, o ESP32 publica
.../adce.../pwmcom o estado atual. - A tela mostra o modo e o estado no rodapé, e o espelho em texto/framebuffer do Lab 06 continua funcionando.
- O client ID continua com sufixo aleatório (o aviso da T4 do Lab 05).
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
const char *TOPICO_ADC = BASE "/adc";
const char *TOPICO_PWM = BASE "/pwm";
const char *TOPICO_CMD_MODO = BASE "/cmd/modo"; // pot | remoto
const char *TOPICO_CMD_AQ = BASE "/cmd/aquecedor"; // 0..100 % (modo remoto)
const char *TOPICO_CMD_VE = BASE "/cmd/ventilador"; // 0..100 % (modo remoto)
enum Modo { MODO_POT, MODO_REMOTO };
const char *NOME_MODO[] = {"pot", "remoto"};
const int N_MODOS = 2;
Modo modo = MODO_POT;
float aqRemoto = 0, veRemoto = 0; // % pedidos por MQTT (modo remoto)
void publicarPwm() {
char t[8] = "null";
if (!isnan(ultimaT)) snprintf(t, sizeof(t), "%.1f", ultimaT);
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, aqPct, vePct,
(unsigned long)dutyDe(aqPct), (unsigned long)dutyDe(vePct), setpoint, t);
mqtt.publish(TOPICO_PWM, payload);
Serial.printf("[PWM] %s\r\n", payload);
}
void controlar() {
float aq = 0, ve = 0;
const char *novoEstado;
switch (modo) {
case MODO_POT: // potenciômetro = "dimmer" dos dois canais
aq = ve = adcRaw * 100.0f / 4095.0f;
novoEstado = "MANUAL";
break;
case MODO_REMOTO: // valores vindos do MQTT
default:
aq = aqRemoto;
ve = veRemoto;
novoEstado = "REMOTO";
break;
}
aq = roundf(aq);
ve = roundf(ve);
if (aq == aqPct && ve == vePct && strcmp(novoEstado, estado) == 0) return; // nada mudou
aqPct = aq;
vePct = ve;
estado = novoEstado;
pwmEscrever(AQ_PIN, AQ_CANAL, dutyDe(aqPct));
pwmEscrever(VE_PIN, VE_CANAL, dutyDe(vePct));
publicarPwm();
telaSuja = true;
}
// no callback aoReceberMensagem(), depois do if do intervalo:
} else if (strcmp(topico, TOPICO_CMD_MODO) == 0) {
int novo = -1;
for (int i = 0; i < N_MODOS; i++)
if (strcasecmp(txt, NOME_MODO[i]) == 0) novo = i;
if (novo < 0) {
Serial.println("[CMD] modo invalido (use pot ou remoto)");
return;
}
modo = (Modo)novo;
controlar();
telaSuja = 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) {
Serial.println("[CMD] use 0..100 (%)");
return;
}
if (strcmp(topico, TOPICO_CMD_AQ) == 0) aqRemoto = v;
else veRemoto = v;
if (modo == MODO_REMOTO) controlar();
else Serial.println("[CMD] guardado; vale no modo remoto");
}
strtof() com o ponteiro fim detecta texto que não é número: se nada foi convertido,
fim == txt. O atof() da T3 do Lab 06 devolveria 0 em silêncio.
Código completo até a T4 (clique para abrir)
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
// ELT85B - Lab 07 (T4): ADC (potenciômetro) + PWM (LEDC) + modos pot/remoto via MQTT
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <Ticker.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "mbedtls/base64.h"
#define GRUPO "a" // troque pela letra do seu grupo
#define DHT_PIN 15
#define DHT_TIPO DHT22
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_ADDR 0x3C
#define OLED_W 128
#define OLED_H 64
// ---- ADC: potenciômetro no GPIO34 (ADC1_CH6 - o ADC1 funciona junto com o Wi-Fi)
#define POT_PIN 34
#define ADC_AMOSTRAS 16 // média de 16 leituras (reduz o ruído)
#define ADC_BANDA 40 // publica só se mudar mais que ~1 % (40/4095)...
#define ADC_REPUB_MS 10000 // ...ou a cada 10 s, para quem acabou de chegar
#define SP_MIN 20.0f // faixa do setpoint (°C)
#define SP_MAX 55.0f
// ---- PWM (LEDC): dois canais com frequências bem diferentes
#define AQ_PIN 25 // "aquecedor": resistência -> PWM lento
#define VE_PIN 26 // "ventilador": ventoinha 4 fios -> 25 kHz
#define AQ_CANAL 0
#define VE_CANAL 1
#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)
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;
#define BASE "elt85b/lab07/grupo-" GRUPO
const char *TOPICO_DADOS = BASE "/dht";
const char *TOPICO_STATUS = BASE "/status";
const char *TOPICO_OLED = BASE "/oled";
const char *TOPICO_OLED_FB = BASE "/oled/fb"; // (Lab 06)
const char *TOPICO_ADC = BASE "/adc"; // T4
const char *TOPICO_PWM = BASE "/pwm"; // T4
const char *TOPICO_INTERVALO = BASE "/cmd/intervalo";
const char *TOPICO_CMD_MODO = BASE "/cmd/modo"; // T4: pot | remoto
const char *TOPICO_CMD_AQ = BASE "/cmd/aquecedor"; // T4: 0..100 % (modo remoto)
const char *TOPICO_CMD_VE = BASE "/cmd/ventilador"; // T4: 0..100 % (modo remoto)
DHT dht(DHT_PIN, DHT_TIPO);
Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
Ticker temporizador; // leitura do DHT22
Ticker temporizadorAdc; // leitura do potenciômetro
volatile bool leituraPendente = false;
volatile bool adcPendente = false;
float intervaloS = 5.0;
uint32_t seq = 0;
float ultimaT = NAN, ultimaH = NAN;
bool telaSuja = true;
char clientId[32];
enum Modo { MODO_POT, MODO_REMOTO };
const char *NOME_MODO[] = {"pot", "remoto"};
const int N_MODOS = 2;
Modo modo = MODO_POT;
int adcRaw = 0, adcMv = 0; // média das leituras
float setpoint = SP_MIN; // °C, vem do potenciômetro
int rawPublicado = -10000; // último raw enviado (banda morta)
unsigned long tAdcPublicado = 0;
float aqPct = -1, vePct = -1; // % aplicados (-1: ainda não aplicado)
float aqRemoto = 0, veRemoto = 0; // % pedidos por MQTT (modo remoto)
const char *estado = "---";
void aoEstourarTemporizador() { leituraPendente = true; }
void aoEstourarTemporizadorAdc() { adcPendente = true; }
// ------------------------------------------------- PWM: core 2.x e 3.x (T3)
void pwmIniciar(uint8_t pino, uint8_t canal, uint32_t freq) {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
ledcAttachChannel(pino, freq, PWM_BITS, canal);
#else
ledcSetup(canal, freq, PWM_BITS);
ledcAttachPin(pino, canal);
#endif
}
void pwmEscrever(uint8_t pino, uint8_t canal, uint32_t duty) {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
(void)canal;
ledcWrite(pino, duty); // 3.x: endereça pelo pino
#else
(void)pino;
ledcWrite(canal, duty); // 2.x: endereça pelo canal
#endif
}
uint32_t dutyDe(float pct) { return (uint32_t)lroundf(pct * PWM_MAX / 100.0f); }
// ---------------------------------------------------------------- ADC (T2)
void lerAdc() {
uint32_t somaRaw = 0, somaMv = 0;
for (int i = 0; i < ADC_AMOSTRAS; i++) {
somaRaw += analogRead(POT_PIN);
somaMv += analogReadMilliVolts(POT_PIN);
}
adcRaw = somaRaw / ADC_AMOSTRAS;
adcMv = somaMv / ADC_AMOSTRAS;
float sp = SP_MIN + adcRaw * (SP_MAX - SP_MIN) / 4095.0f;
setpoint = roundf(sp * 2) / 2; // passos de 0,5 °C
}
// ------------------------------------------------------------- OLED
void indicador(int x, const char *letra, bool ok) {
if (ok) {
oled.fillRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_BLACK);
} else {
oled.drawRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_WHITE);
}
oled.setCursor(x + 4, 1);
oled.print(letra);
oled.setTextColor(SSD1306_WHITE);
}
void barra(int y, const char *rotulo, float pct) {
oled.setCursor(0, y);
oled.print(rotulo);
oled.drawRect(16, y, 80, 8, SSD1306_WHITE);
oled.fillRect(18, y + 2, (int)(76 * pct / 100.0f), 4, SSD1306_WHITE);
oled.setCursor(100, y);
oled.printf("%3.0f%%", pct);
}
void desenharTela() {
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
oled.setTextSize(1); // cabeçalho
oled.setCursor(0, 1);
oled.print("LAB07 grupo " GRUPO);
indicador(98, "W", WiFi.status() == WL_CONNECTED);
indicador(114, "M", mqtt.connected());
oled.drawFastHLine(0, 11, OLED_W, SSD1306_WHITE);
oled.setTextSize(2); // temperatura medida
oled.setCursor(0, 15);
if (isnan(ultimaT)) oled.print("--.-");
else oled.printf("%4.1f", ultimaT);
oled.drawCircle(53, 17, 2, SSD1306_WHITE);
oled.setCursor(58, 15);
oled.print("C");
oled.setTextSize(1); // setpoint e ADC
oled.setCursor(76, 15);
oled.printf("SP %4.1f", setpoint);
oled.setCursor(76, 24);
oled.printf("%4d mV", adcMv);
barra(35, "AQ", aqPct < 0 ? 0 : aqPct); // atuadores
barra(45, "VE", vePct < 0 ? 0 : vePct);
oled.setCursor(0, 56); // modo e estado
oled.printf("%s: %s", NOME_MODO[modo], estado);
oled.display();
}
void publicarTelaTexto() {
char t[8] = "--.-";
if (!isnan(ultimaT)) snprintf(t, sizeof(t), "%.1f", ultimaT);
char payload[220];
snprintf(payload, sizeof(payload),
"{\"linhas\":[\"LAB07 grupo %s\",\"T: %s C SP: %.1f C\",\"AQ: %.0f %% VE: %.0f %%\","
"\"modo %s | %s\",\"WiFi %s | MQTT %s\"]}",
GRUPO, t, setpoint, aqPct < 0 ? 0 : aqPct, vePct < 0 ? 0 : vePct,
NOME_MODO[modo], estado,
WiFi.status() == WL_CONNECTED ? "ok" : "--", mqtt.connected() ? "ok" : "--");
mqtt.publish(TOPICO_OLED, payload);
}
void publicarFramebuffer() {
static unsigned char b64[1400];
size_t n = 0;
mbedtls_base64_encode(b64, sizeof(b64), &n, oled.getBuffer(), OLED_W * OLED_H / 8);
if (!mqtt.publish(TOPICO_OLED_FB, b64, n, false))
Serial.println("[FB] publish falhou: aumente mqtt.setBufferSize()");
}
// ------------------------------------------------- publicação de ADC e PWM (T4)
void publicarAdc() {
char payload[96];
snprintf(payload, sizeof(payload), "{\"raw\":%d,\"mv\":%d,\"sp\":%.1f}", adcRaw, adcMv, setpoint);
mqtt.publish(TOPICO_ADC, payload);
rawPublicado = adcRaw;
tAdcPublicado = millis();
}
void publicarPwm() {
char t[8] = "null";
if (!isnan(ultimaT)) snprintf(t, sizeof(t), "%.1f", ultimaT);
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, aqPct, vePct,
(unsigned long)dutyDe(aqPct), (unsigned long)dutyDe(vePct), setpoint, t);
mqtt.publish(TOPICO_PWM, payload);
Serial.printf("[PWM] %s\r\n", payload);
}
// ------------------------------------------------- decisão dos atuadores (T3/T4)
void controlar() {
float aq = 0, ve = 0;
const char *novoEstado;
switch (modo) {
case MODO_POT: // T3: potenciômetro = "dimmer" dos dois canais
aq = ve = adcRaw * 100.0f / 4095.0f;
novoEstado = "MANUAL";
break;
case MODO_REMOTO: // T4: valores vindos do MQTT
default:
aq = aqRemoto;
ve = veRemoto;
novoEstado = "REMOTO";
break;
}
aq = roundf(aq);
ve = roundf(ve);
if (aq == aqPct && ve == vePct && strcmp(novoEstado, estado) == 0) return; // nada mudou
aqPct = aq;
vePct = ve;
estado = novoEstado;
pwmEscrever(AQ_PIN, AQ_CANAL, dutyDe(aqPct));
pwmEscrever(VE_PIN, VE_CANAL, dutyDe(vePct));
publicarPwm();
telaSuja = true;
}
// ---------------------------------------------------------------- comandos
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[16];
size_t n = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, n);
txt[n] = '\0';
Serial.printf("[CMD] %s <- '%s'\r\n", topico, txt);
if (strcmp(topico, TOPICO_INTERVALO) == 0) {
float v = atof(txt);
if (v < 2.0 || v > 60.0) {
Serial.println("[CMD] intervalo fora de 2..60 s - ignorado");
return;
}
intervaloS = v;
temporizador.detach();
temporizador.attach(intervaloS, aoEstourarTemporizador);
telaSuja = true;
} else if (strcmp(topico, TOPICO_CMD_MODO) == 0) {
int novo = -1;
for (int i = 0; i < N_MODOS; i++)
if (strcasecmp(txt, NOME_MODO[i]) == 0) novo = i;
if (novo < 0) {
Serial.println("[CMD] modo invalido (use pot ou remoto)");
return;
}
modo = (Modo)novo;
controlar();
telaSuja = 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) {
Serial.println("[CMD] use 0..100 (%)");
return;
}
if (strcmp(topico, TOPICO_CMD_AQ) == 0) aqRemoto = v;
else veRemoto = v;
if (modo == MODO_REMOTO) controlar();
else Serial.println("[CMD] guardado; vale no modo remoto");
}
}
// ------------------------------------------------------------ Wi-Fi e MQTT
void conectarWiFi() {
Serial.printf("[WiFi] conectando a %s", WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA, 6);
while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print('.');
}
Serial.printf("\r\n[WiFi] conectado, IP %s\r\n", WiFi.localIP().toString().c_str());
}
void conectarMQTT() {
while (!mqtt.connected()) {
Serial.printf("[MQTT] conectando a %s como %s ... ", MQTT_HOST, clientId);
if (mqtt.connect(clientId, TOPICO_STATUS, 1, true, "offline")) {
Serial.println("ok");
mqtt.publish(TOPICO_STATUS, "online", true);
mqtt.subscribe(TOPICO_INTERVALO);
mqtt.subscribe(TOPICO_CMD_MODO);
mqtt.subscribe(TOPICO_CMD_AQ);
mqtt.subscribe(TOPICO_CMD_VE);
publicarAdc(); // estado atual para quem acabou de chegar
publicarPwm();
telaSuja = true;
} else {
Serial.printf("falhou (rc=%d), nova tentativa em 2 s\r\n", mqtt.state());
delay(2000);
}
}
}
void lerEPublicar() {
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) {
Serial.println("[DHT] falha na leitura (NaN) - descartada");
return;
}
seq++;
ultimaT = t;
ultimaH = 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)millis(), intervaloS);
bool ok = mqtt.publish(TOPICO_DADOS, payload);
Serial.printf("[PUB] %s %s -> %s\r\n", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
telaSuja = true;
}
void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 07 - ADC + PWM + MQTT ===");
dht.begin();
analogReadResolution(12); // 0..4095
analogSetPinAttenuation(POT_PIN, ADC_11db); // faixa de ~0 a 3,1 V
pwmIniciar(AQ_PIN, AQ_CANAL, AQ_FREQ_HZ);
pwmIniciar(VE_PIN, VE_CANAL, VE_FREQ_HZ);
lerAdc();
controlar();
Wire.begin(OLED_SDA, OLED_SCL);
if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
Serial.println("[OLED] SSD1306 nao encontrado - confira SDA/SCL/endereco");
}
desenharTela();
// sufixo aleatorio: no Wokwi, todos os ESP32 simulados tem o MESMO MAC
snprintf(clientId, sizeof(clientId), "lab07-%s-%04lX", GRUPO, (unsigned long)(esp_random() & 0xFFFF));
conectarWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
mqtt.setBufferSize(1600);
conectarMQTT();
temporizador.attach(intervaloS, aoEstourarTemporizador);
temporizadorAdc.attach_ms(100, aoEstourarTemporizadorAdc); // 10 Hz
}
void loop() {
if (WiFi.status() != WL_CONNECTED) conectarWiFi();
if (!mqtt.connected()) conectarMQTT();
mqtt.loop();
if (adcPendente) {
adcPendente = false;
lerAdc();
if (abs(adcRaw - rawPublicado) > ADC_BANDA) { // banda morta: ignora o ruído
publicarAdc();
controlar();
telaSuja = true;
} else if (millis() - tAdcPublicado >= ADC_REPUB_MS) {
publicarAdc(); // sem mudança: só "ainda estou aqui"
}
}
if (leituraPendente) {
leituraPendente = false;
lerEPublicar();
}
if (telaSuja) {
telaSuja = false;
desenharTela();
publicarTelaTexto();
publicarFramebuffer();
}
}
4.2 Testando pelo terminal
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/adc" -t "elt85b/lab07/grupo-a/pwm" -t "elt85b/lab07/grupo-a/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-a/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/adc" -t "elt85b/lab07/grupo-b/pwm" -t "elt85b/lab07/grupo-b/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-b/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/adc" -t "elt85b/lab07/grupo-c/pwm" -t "elt85b/lab07/grupo-c/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-c/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/adc" -t "elt85b/lab07/grupo-d/pwm" -t "elt85b/lab07/grupo-d/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-d/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/adc" -t "elt85b/lab07/grupo-e/pwm" -t "elt85b/lab07/grupo-e/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-e/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/adc" -t "elt85b/lab07/grupo-f/pwm" -t "elt85b/lab07/grupo-f/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-f/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/adc" -t "elt85b/lab07/grupo-g/pwm" -t "elt85b/lab07/grupo-g/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-g/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/adc" -t "elt85b/lab07/grupo-h/pwm" -t "elt85b/lab07/grupo-h/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-h/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/adc" -t "elt85b/lab07/grupo-i/pwm" -t "elt85b/lab07/grupo-i/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-i/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/adc" -t "elt85b/lab07/grupo-j/pwm" -t "elt85b/lab07/grupo-j/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-j/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/adc" -t "elt85b/lab07/grupo-k/pwm" -t "elt85b/lab07/grupo-k/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-k/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/adc" -t "elt85b/lab07/grupo-l/pwm" -t "elt85b/lab07/grupo-l/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-l/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/adc" -t "elt85b/lab07/grupo-m/pwm" -t "elt85b/lab07/grupo-m/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-m/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/adc" -t "elt85b/lab07/grupo-x/pwm" -t "elt85b/lab07/grupo-x/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-x/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/adc" -t "elt85b/lab07/grupo-p/pwm" -t "elt85b/lab07/grupo-p/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-p/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
1. 1. Assinar (sem o framebuffer):
docker run -d --name sub-lab07 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/adc" -t "elt85b/lab07/grupo-n/pwm" -t "elt85b/lab07/grupo-n/cmd/#" -v
docker logs -f sub-lab07
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/cmd/modo" -m remoto
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/cmd/aquecedor" -m 30
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/cmd/ventilador" -m 80
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/cmd/aquecedor" -m 150
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/cmd/modo" -m turbo
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab07/grupo-n/cmd/modo" -m pot
3. 3. Gravar e encerrar:
docker logs sub-lab07 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab07
Saída esperada (gire o potenciômetro antes dos comandos):
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-a/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-a/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-a/cmd/modo remoto
elt85b/lab07/grupo-a/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-a/cmd/aquecedor 30
elt85b/lab07/grupo-a/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-a/cmd/ventilador 80
elt85b/lab07/grupo-a/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-a/cmd/aquecedor 150
elt85b/lab07/grupo-a/cmd/modo turbo
elt85b/lab07/grupo-a/cmd/modo pot
elt85b/lab07/grupo-a/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-b/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-b/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-b/cmd/modo remoto
elt85b/lab07/grupo-b/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-b/cmd/aquecedor 30
elt85b/lab07/grupo-b/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-b/cmd/ventilador 80
elt85b/lab07/grupo-b/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-b/cmd/aquecedor 150
elt85b/lab07/grupo-b/cmd/modo turbo
elt85b/lab07/grupo-b/cmd/modo pot
elt85b/lab07/grupo-b/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-c/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-c/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-c/cmd/modo remoto
elt85b/lab07/grupo-c/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-c/cmd/aquecedor 30
elt85b/lab07/grupo-c/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-c/cmd/ventilador 80
elt85b/lab07/grupo-c/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-c/cmd/aquecedor 150
elt85b/lab07/grupo-c/cmd/modo turbo
elt85b/lab07/grupo-c/cmd/modo pot
elt85b/lab07/grupo-c/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-d/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-d/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-d/cmd/modo remoto
elt85b/lab07/grupo-d/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-d/cmd/aquecedor 30
elt85b/lab07/grupo-d/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-d/cmd/ventilador 80
elt85b/lab07/grupo-d/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-d/cmd/aquecedor 150
elt85b/lab07/grupo-d/cmd/modo turbo
elt85b/lab07/grupo-d/cmd/modo pot
elt85b/lab07/grupo-d/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-e/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-e/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-e/cmd/modo remoto
elt85b/lab07/grupo-e/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-e/cmd/aquecedor 30
elt85b/lab07/grupo-e/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-e/cmd/ventilador 80
elt85b/lab07/grupo-e/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-e/cmd/aquecedor 150
elt85b/lab07/grupo-e/cmd/modo turbo
elt85b/lab07/grupo-e/cmd/modo pot
elt85b/lab07/grupo-e/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-f/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-f/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-f/cmd/modo remoto
elt85b/lab07/grupo-f/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-f/cmd/aquecedor 30
elt85b/lab07/grupo-f/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-f/cmd/ventilador 80
elt85b/lab07/grupo-f/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-f/cmd/aquecedor 150
elt85b/lab07/grupo-f/cmd/modo turbo
elt85b/lab07/grupo-f/cmd/modo pot
elt85b/lab07/grupo-f/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-g/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-g/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-g/cmd/modo remoto
elt85b/lab07/grupo-g/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-g/cmd/aquecedor 30
elt85b/lab07/grupo-g/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-g/cmd/ventilador 80
elt85b/lab07/grupo-g/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-g/cmd/aquecedor 150
elt85b/lab07/grupo-g/cmd/modo turbo
elt85b/lab07/grupo-g/cmd/modo pot
elt85b/lab07/grupo-g/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-h/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-h/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-h/cmd/modo remoto
elt85b/lab07/grupo-h/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-h/cmd/aquecedor 30
elt85b/lab07/grupo-h/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-h/cmd/ventilador 80
elt85b/lab07/grupo-h/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-h/cmd/aquecedor 150
elt85b/lab07/grupo-h/cmd/modo turbo
elt85b/lab07/grupo-h/cmd/modo pot
elt85b/lab07/grupo-h/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-i/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-i/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-i/cmd/modo remoto
elt85b/lab07/grupo-i/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-i/cmd/aquecedor 30
elt85b/lab07/grupo-i/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-i/cmd/ventilador 80
elt85b/lab07/grupo-i/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-i/cmd/aquecedor 150
elt85b/lab07/grupo-i/cmd/modo turbo
elt85b/lab07/grupo-i/cmd/modo pot
elt85b/lab07/grupo-i/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-j/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-j/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-j/cmd/modo remoto
elt85b/lab07/grupo-j/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-j/cmd/aquecedor 30
elt85b/lab07/grupo-j/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-j/cmd/ventilador 80
elt85b/lab07/grupo-j/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-j/cmd/aquecedor 150
elt85b/lab07/grupo-j/cmd/modo turbo
elt85b/lab07/grupo-j/cmd/modo pot
elt85b/lab07/grupo-j/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-k/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-k/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-k/cmd/modo remoto
elt85b/lab07/grupo-k/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-k/cmd/aquecedor 30
elt85b/lab07/grupo-k/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-k/cmd/ventilador 80
elt85b/lab07/grupo-k/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-k/cmd/aquecedor 150
elt85b/lab07/grupo-k/cmd/modo turbo
elt85b/lab07/grupo-k/cmd/modo pot
elt85b/lab07/grupo-k/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-l/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-l/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-l/cmd/modo remoto
elt85b/lab07/grupo-l/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-l/cmd/aquecedor 30
elt85b/lab07/grupo-l/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-l/cmd/ventilador 80
elt85b/lab07/grupo-l/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-l/cmd/aquecedor 150
elt85b/lab07/grupo-l/cmd/modo turbo
elt85b/lab07/grupo-l/cmd/modo pot
elt85b/lab07/grupo-l/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-m/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-m/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-m/cmd/modo remoto
elt85b/lab07/grupo-m/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-m/cmd/aquecedor 30
elt85b/lab07/grupo-m/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-m/cmd/ventilador 80
elt85b/lab07/grupo-m/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-m/cmd/aquecedor 150
elt85b/lab07/grupo-m/cmd/modo turbo
elt85b/lab07/grupo-m/cmd/modo pot
elt85b/lab07/grupo-m/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-x/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-x/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-x/cmd/modo remoto
elt85b/lab07/grupo-x/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-x/cmd/aquecedor 30
elt85b/lab07/grupo-x/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-x/cmd/ventilador 80
elt85b/lab07/grupo-x/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-x/cmd/aquecedor 150
elt85b/lab07/grupo-x/cmd/modo turbo
elt85b/lab07/grupo-x/cmd/modo pot
elt85b/lab07/grupo-x/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-p/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-p/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-p/cmd/modo remoto
elt85b/lab07/grupo-p/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-p/cmd/aquecedor 30
elt85b/lab07/grupo-p/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-p/cmd/ventilador 80
elt85b/lab07/grupo-p/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-p/cmd/aquecedor 150
elt85b/lab07/grupo-p/cmd/modo turbo
elt85b/lab07/grupo-p/cmd/modo pot
elt85b/lab07/grupo-p/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
1. Exemplo de Evidência de Saída:
elt85b/lab07/grupo-n/adc {"raw":3000,"mv":2420,"sp":45.5}
elt85b/lab07/grupo-n/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-n/cmd/modo remoto
elt85b/lab07/grupo-n/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-n/cmd/aquecedor 30
elt85b/lab07/grupo-n/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-n/cmd/ventilador 80
elt85b/lab07/grupo-n/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt85b/lab07/grupo-n/cmd/aquecedor 150
elt85b/lab07/grupo-n/cmd/modo turbo
elt85b/lab07/grupo-n/cmd/modo pot
elt85b/lab07/grupo-n/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
Repare que aquecedor 150 e modo turbo não geram .../pwm: o ESP32 recusou os dois.
P3: com ADC_BANDA = 0, quantas mensagens por segundo iriam para .../adc numa placa
real, com o potenciômetro parado? E no Wokwi, cujo ADC não tem ruído? Por que, mesmo com a
banda morta, vale publicar .../adc a cada 10 s? Pense no dashboard aberto depois da
última mudança.
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- └── 📂evidencias
- └── 📄t4-mqtt.txt👈 Criar Aqui
git conferir src/main.cpp evidencias/t4-mqtt.txt
ADC e PWM no MQTT, modos pot e remoto
git conferir src/main.cpp evidencias/t4-mqtt.txt
git add src/main.cpp evidencias/t4-mqtt.txt && git commit -m "T4: ADC e PWM no MQTT, modos pot e remoto" && 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 — Node-RED: SQLite e dashboard de comando
Crie uma aba Lab 07. Cada mensagem .../pwm é um evento de mudança dos atuadores,
e cada evento vira uma linha no SQLite. Como cada linha vale até a próxima, dá para
calcular por quanto tempo cada estado durou e a energia do aquecedor.
5.1 Tabela e gravação
Banco /data/sqlite/lab07.sqlite (Read-Write-Create). Crie a tabela com um inject
"Criar tabela" (once, 0,5 s) → sqlite Via msg.topic:
CREATE TABLE IF NOT EXISTS atuacao (
id INTEGER PRIMARY KEY AUTOINCREMENT,
recebido_em TEXT DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now', 'localtime')),
modo TEXT, -- pot | remoto | auto
estado TEXT, -- MANUAL | REMOTO | AQUECENDO | ESTAVEL | RESFRIANDO | SEM DHT
aq REAL, -- % aplicado no aquecedor
ve REAL, -- % aplicado no ventilador
aq_duty INTEGER, -- 0..255 (LEDC 8 bits)
ve_duty INTEGER,
sp REAL, -- setpoint do potenciômetro (°C)
t REAL -- temperatura no instante da mudança
);
mqtt in elt85b/lab07/grupo-x/pwm (a parsed JSON object) → function → sqlite
Prepared Statement:
// Mensagem .../pwm do ESP32 -> parâmetros do INSERT (só grava o que é válido)
const p = msg.payload;
const pct = (v) => typeof v === "number" && v >= 0 && v <= 100;
if (
!p ||
typeof p !== "object" ||
!pct(p.aq) ||
!pct(p.ve) ||
!["pot", "remoto", "auto"].includes(p.modo)
) {
node.warn("descartado: " + JSON.stringify(p));
return null;
}
msg.params = {
$modo: p.modo,
$estado: String(p.estado ?? ""),
$aq: p.aq,
$ve: p.ve,
$aq_duty: p.aq_duty ?? null,
$ve_duty: p.ve_duty ?? null,
$sp: typeof p.sp === "number" ? p.sp : null,
$t: typeof p.t === "number" ? p.t : null,
};
node.status({
fill: "green",
shape: "dot",
text: `${p.modo} ${p.estado} AQ ${p.aq}% VE ${p.ve}%`,
});
return msg;
INSERT INTO atuacao (modo, estado, aq, ve, aq_duty, ve_duty, sp, t)
VALUES ($modo, $estado, $aq, $ve, $aq_duty, $ve_duty, $sp, $t);
5.2 Consultas com LEAD()
No Lab 06, LAG() olhava a linha anterior. Aqui usamos LEAD(), que olha a
próxima: a duração de um estado é o tempo até a mudança seguinte. A última linha ainda está
"em andamento", então o LEAD() usa o agora como valor padrão.
SELECT estado, COUNT(*) AS trocas, ROUND(SUM(dt_s), 1) AS segundos
FROM (SELECT estado, (julianday(LEAD(recebido_em, 1, strftime('%Y-%m-%d %H:%M:%f', 'now', 'localtime'))
OVER (ORDER BY id)) - julianday(recebido_em)) * 86400 AS dt_s FROM atuacao)
GROUP BY estado ORDER BY segundos DESC;
SELECT ROUND(SUM(25.0 * aq / 100.0 * dt_s) / 3600.0, 4) AS energia_wh,
ROUND(SUM(dt_s) / 60.0, 1) AS minutos,
ROUND(SUM(aq * dt_s) / SUM(dt_s), 1) AS duty_medio_pct
FROM (SELECT aq, (julianday(LEAD(recebido_em, 1, strftime('%Y-%m-%d %H:%M:%f', 'now', 'localtime'))
OVER (ORDER BY id)) - julianday(recebido_em)) * 86400 AS dt_s FROM atuacao);
energia_wh soma potência × tempo: 25 W × (duty em %) × duração. duty_medio_pct é a média
ponderada pelo tempo, que é diferente da média simples das linhas. Crie também um inject
"Últimas 10 mudanças" (SELECT ... FROM atuacao ORDER BY id DESC LIMIT 10;).
5.3 Dashboard
Na página Lab 07 (caminho /lab07) do My Dashboard, crie os grupos ESP32 (OLED),
Potenciômetro (ADC), Atuadores (PWM), Comando e Histórico (SQLite).
-
Tela: copie da aba Lab 06 o ui-template do framebuffer, troque o tópico do
mqtt inparaelt85b/lab07/grupo-x/oled/fbe coloque-o no grupo ESP32 (OLED), com um ui-text do.../status. -
ADC: mqtt in
.../adc→ function com 4 saídas → ui-gauge "Tensão no GPIO34" (0–3300 mV), ui-text "Leitura (12 bits)", ui-text "Setpoint" e o gráfico de temperatura (série SP):function: adc -> widgets (4 saídas)// .../adc -> gauge de tensão, textos e ponto do setpoint no gráficoconst p = msg.payload;if (typeof p?.raw !== "number") return null;return [{ payload: p.mv },{ payload: `${p.raw} / 4095 (${((100 * p.raw) / 4095).toFixed(1)} %)` },{ payload: `${p.sp.toFixed(1)} °C` },{ payload: [{ ts: Date.now(), serie: "SP (°C)", valor: p.sp }] },]; -
PWM e comando: mqtt in
.../pwm→ function com 7 saídas:function: pwm -> widgets (7 saídas)// .../pwm -> gauges, estado, gráfico (degrau) e sincronia dos comandosconst p = msg.payload;if (typeof p?.aq !== "number") return null;const ts = Date.now();const ant = context.get("ant") || {};context.set("ant", p);const mudou = (k) => ant[k] !== p[k];return [{ payload: p.aq },{ payload: p.ve },{ payload: `${p.estado} (modo ${p.modo})` },{payload: [{ ts, serie: "Aquecedor (%)", valor: p.aq },{ ts, serie: "Ventilador (%)", valor: p.ve },],},mudou("modo") ? { payload: p.modo } : null, // botões do modop.modo === "remoto" && mudou("aq") ? { payload: p.aq } : null, // sliders só no remotop.modo === "remoto" && mudou("ve") ? { payload: p.ve } : null,];Saída Nó 1, 2 ui-gauge "Aquecedor" e "Ventilador" (0–100 %) 3 ui-text "Estado" 4 ui-chart "PWM aplicado": Series = key serie, X = keyts, Y = keyvalor, interpolação step5 ui-button-group "Modo": opções pot,remoto,auto; Topicelt85b/lab07/grupo-x/cmd/modo; pass-through desligado6, 7 ui-slider "Aquecedor no remoto" e "Ventilador no remoto": 0–100, passo 5, Topic .../cmd/aquecedore.../cmd/ventilador, on release, pass-through desligadoLigue o button-group e os dois sliders a um mqtt out com tópico vazio, que usa
msg.topic. -
Temperatura: mqtt in
.../dht→ function → o gráfico "Temperatura × setpoint" (série T):function: dht -> gráfico// .../dht -> ponto da temperatura no gráficoconst p = msg.payload;if (typeof p?.t !== "number") return null;return { payload: [{ ts: Date.now(), serie: "T (°C)", valor: p.t }] }; -
Histórico: inject (once, 2 s) → sqlite Fixed
SELECT recebido_em, t, sp, aq, ve FROM atuacao ORDER BY id DESC LIMIT 200;→ function com 2 saídas → os dois gráficos. Complete com inject a cada 10 s → sqlite "últimas 8" → ui-table.function: linhas -> pontos (2 saídas)// Linhas de 'atuacao' -> pontos dos dois gráficos (substitui o que havia)const temp = [],pwm = [];for (const r of msg.payload.reverse()) {const ts = new Date(r.recebido_em.replace(" ", "T")).getTime();if (r.t !== null) temp.push({ ts, serie: "T (°C)", valor: r.t });if (r.sp !== null) temp.push({ ts, serie: "SP (°C)", valor: r.sp });pwm.push({ ts, serie: "Aquecedor (%)", valor: r.aq },{ ts, serie: "Ventilador (%)", valor: r.ve },);}node.status({ text: `${msg.payload.length} linhas carregadas` });return [{ payload: temp, action: "replace" },{ payload: pwm, action: "replace" },];
Com o dashboard aberto em http://localhost/lab07-x/dashboard/lab07:
- clique Remoto e mova os sliders: os LEDs no Wokwi, as barras no OLED e os gauges mudam juntos;
- clique Potenciômetro e gire o knob no Wokwi: os sliders não se mexem (eles só acompanham o modo remoto).
Evidências: a saída de "Últimas 10 mudanças" e de "Tempo em cada estado" em
evidencias/t5-sqlite.txt, a captura do dashboard em evidencias/t5-dashboard.png e o
fluxo exportado em nodered/flows-lab07.json.
- ├── 📂nodered
- └── 🔧flows-lab07.json👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t5-sqlite.txt👈 Criar Aqui
- └── 📄t5-dashboard.png👈 Criar Aqui
git conferir nodered/flows-lab07.json evidencias/t5-sqlite.txt evidencias/t5-dashboard.png
Node-RED: SQLite e dashboard de comando
git conferir nodered/flows-lab07.json evidencias/t5-sqlite.txt evidencias/t5-dashboard.png
git add nodered/flows-lab07.json evidencias/t5-sqlite.txt evidencias/t5-dashboard.png && git commit -m "T5: Node-RED: SQLite e dashboard de comando" && 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 — modo auto: controle ON/OFF com histerese
Agora o ESP32 decide sozinho. No modo auto, o potenciômetro é o setpoint (SP), e a
cada leitura do DHT22:
- o aquecedor liga (100 %) quando T fica abaixo de SP − 0,5 °C e desliga (0 %) quando passa de SP + 0,5 °C. Entre os dois limites, mantém o que estava fazendo: isso é a histerese;
- o ventilador fica em 0 % até SP + 1 °C e sobe 25 % por °C acima disso (controle proporcional, limitado a 100 %).
T = 24,5 °C → AQUECENDO aquecedor 100 %, ventilador 0 %
T = 37,4 °C → (mantém) está dentro da faixa 37,0 … 38,0: continua aquecendo
T = 38,2 °C → ESTAVEL aquecedor 0 %, ventilador 0 %
T = 41,0 °C → RESFRIANDO aquecedor 0 %, ventilador 63 % (41 − 38,5) × 25 = 62,5
Requisitos
- Firmware
- Terceiro modo
auto(N_MODOS = 3), aceito em.../cmd/modo. - Variável
aquecendoque guarda o estado da histerese, zerada ao trocar de modo. - Estados publicados:
AQUECENDO,ESTAVEL,RESFRIANDOeSEM DHT(antes da primeira leitura válida). - Chamar
controlar()também depois de cada leitura do DHT22, porque no modoautoa temperatura nova pode mudar a decisão.
- Terceiro modo
- Node-RED: botão Automático no button-group (valor
auto). - Experimento no Wokwi (você é a planta): modo
auto, SP ≈ 37,5 °C, e leve a temperatura do DHT22 por 24,5 → 37,4 → 38,2 → 41,0 → 37,8 → 36,8 °C, esperando uma leitura em cada valor. - Evidências
evidencias/t6-serial.txt: as linhas[PWM]do experimento.evidencias/t6-sqlite.txt: saída de "Tempo em cada estado" e "Energia do aquecedor".- O fluxo exportado de novo em
nodered/flows-lab07.json.
Saída esperada (trecho do serial):
[PWM] {"modo":"auto","estado":"AQUECENDO","aq":100,"ve":0,"aq_duty":255,"ve_duty":0,"sp":37.5,"t":24.5}
[PWM] {"modo":"auto","estado":"ESTAVEL","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":37.5,"t":38.2}
[PWM] {"modo":"auto","estado":"RESFRIANDO","aq":0,"ve":63,"aq_duty":0,"ve_duty":161,"sp":37.5,"t":41.0}
[PWM] {"modo":"auto","estado":"ESTAVEL","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":37.5,"t":37.8}
[PWM] {"modo":"auto","estado":"AQUECENDO","aq":100,"ve":0,"aq_duty":255,"ve_duty":0,"sp":37.5,"t":36.8}
Em 37,4 °C não aparece linha nova: a histerese manteve o aquecedor ligado. Em 37,8 °C também não religou, porque ainda estava acima de SP − 0,5 = 37,0 °C.
Dicas de API
#define HISTERESE 0.5f // ±0,5 °C
enum Modo { MODO_POT, MODO_REMOTO, MODO_AUTO };
const char *NOME_MODO[] = {"pot", "remoto", "auto"};
const int N_MODOS = 3;
bool aquecendo = false; // memória da histerese
// novo case em controlar():
case MODO_AUTO:
if (isnan(ultimaT)) { novoEstado = "SEM DHT"; break; }
if (ultimaT < setpoint - HISTERESE) aquecendo = true;
else if (ultimaT > setpoint + HISTERESE) aquecendo = false;
// senão: mantém 'aquecendo' como está
aq = aquecendo ? 100 : 0;
ve = constrain((ultimaT - setpoint - 1.0f) * 25.0f, 0.0f, 100.0f);
novoEstado = ...; // AQUECENDO / RESFRIANDO / ESTAVEL
break;
P4: com HISTERESE = 0 e um sensor que oscila ±0,1 °C em torno do setpoint, o que
aconteceria com o aquecedor? Por que isso é ruim para um relé ou contator real? Com o DHT22
lido a cada 5 s, quantas vezes por minuto o aquecedor pode, no máximo, trocar de estado?
Compare a "Energia do aquecedor" de 5 minutos em auto com 5 minutos em pot com o knob em
50 %.
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 📂nodered
- └── 🔧flows-lab07.json👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t6-serial.txt👈 Criar Aqui
- └── 📄t6-sqlite.txt👈 Criar Aqui
git conferir src/main.cpp nodered/flows-lab07.json evidencias/t6-serial.txt evidencias/t6-sqlite.txt
Modo auto: controle ON/OFF com histerese
git conferir src/main.cpp nodered/flows-lab07.json evidencias/t6-serial.txt evidencias/t6-sqlite.txt
git add src/main.cpp nodered/flows-lab07.json evidencias/t6-serial.txt evidencias/t6-sqlite.txt && git commit -m "T6: Modo auto: controle ON/OFF com histerese" && 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
Para o git "esquecer" suas informações salvas:
git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
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.