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: dashboard mínimo com a tela, o estado, os botões de modo e os 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
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 e um dashboard mínimo no Node-RED, 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, montar um dashboard mínimo de comando (modo e sliders) que mostra o estado confirmado pelo ESP32. Registrar as mudanças num banco fica para o Lab 08.
- (Integrador) Implementar um controle ON/OFF com histerese.
Material
- VS Code + PlatformIO + extensão Wokwi (ESP32 simulado).
- Stack Docker do curso: Node-RED com 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/ELT73A-S22-2026-2/lab07-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-a/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-b/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-c/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-d/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-e/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-f/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-g/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-h/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-i/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-j/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-k/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-l/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-m/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-x/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-p/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\lab07-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab07-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab07-grupo-n/commits/main/
- Acessos: ACESSO-LAB07.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/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%\ELT73AS22\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.
Suba os containers
Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Disciplina: ELT73A - Sistemas Microcontrolados.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\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 elt73a --lab lab07 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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%\ELT73AS22\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 elt73a --lab lab07 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop 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.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Circuito: potenciometro, LEDs e analisador logico · 10 pts
- T2 — Leitura do potenciometro 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: 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-dashboard.png👈 Criar Aqui
- ├── 📄t6-serial.txt👈 Criar Aqui
- └── 📄t6-dashboard.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Tudo fica sob elt73a/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": "elt73a - 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": {
"channelNames": "aquecedor,ventilador",
"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: potenciometro, LEDs e analisador logico
git conferir diagram.json
git add diagram.json && git commit -m "T1: Circuito: potenciometro, LEDs e analisador logico" && 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 potenciometro 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 potenciometro 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 |
| 2 | 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) |
Cada canal do LEDC usa um timer, e é o timer que define a frequência. No core 2.x,
ledcSetup(canal, ...) escolhe o timer pelo número do canal: timer = (canal / 2) % 4. Os canais
0 e 1 dividem o timer 0: se o ventilador usasse o canal 1, o ledcSetup() dele (25 kHz)
mudaria também a frequência do aquecedor. Por isso o ventilador fica no canal 2 (timer 1).
- └── 📂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 2 // canal 2 = timer 1 (veja a nota "Canal e timer")
#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 o arquivo wokwi.vcd na raiz do projeto. 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.
- └── 📂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 T4 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
// elt73a - 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 2 // canal 2 = timer 1 (veja a nota "Canal e timer")
#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 "elt73a/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();
uint64_t mac = ESP.getEfuseMac();
snprintf(clientId, sizeof(clientId), "lab07-%s-%04X", GRUPO, (uint16_t)(mac >> 32));
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 tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-a/adc' -t 'elt73a/lab07/grupo-a/pwm' -t 'elt73a/lab07/grupo-a/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-a/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-a/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-a/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-a/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-a/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-a/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-b/adc' -t 'elt73a/lab07/grupo-b/pwm' -t 'elt73a/lab07/grupo-b/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-b/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-b/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-b/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-b/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-b/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-b/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-c/adc' -t 'elt73a/lab07/grupo-c/pwm' -t 'elt73a/lab07/grupo-c/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-c/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-c/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-c/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-c/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-c/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-c/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-d/adc' -t 'elt73a/lab07/grupo-d/pwm' -t 'elt73a/lab07/grupo-d/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-d/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-d/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-d/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-d/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-d/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-d/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-e/adc' -t 'elt73a/lab07/grupo-e/pwm' -t 'elt73a/lab07/grupo-e/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-e/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-e/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-e/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-e/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-e/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-e/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-f/adc' -t 'elt73a/lab07/grupo-f/pwm' -t 'elt73a/lab07/grupo-f/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-f/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-f/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-f/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-f/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-f/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-f/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-g/adc' -t 'elt73a/lab07/grupo-g/pwm' -t 'elt73a/lab07/grupo-g/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-g/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-g/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-g/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-g/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-g/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-g/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-h/adc' -t 'elt73a/lab07/grupo-h/pwm' -t 'elt73a/lab07/grupo-h/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-h/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-h/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-h/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-h/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-h/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-h/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-i/adc' -t 'elt73a/lab07/grupo-i/pwm' -t 'elt73a/lab07/grupo-i/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-i/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-i/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-i/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-i/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-i/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-i/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-j/adc' -t 'elt73a/lab07/grupo-j/pwm' -t 'elt73a/lab07/grupo-j/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-j/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-j/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-j/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-j/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-j/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-j/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-k/adc' -t 'elt73a/lab07/grupo-k/pwm' -t 'elt73a/lab07/grupo-k/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-k/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-k/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-k/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-k/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-k/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-k/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-l/adc' -t 'elt73a/lab07/grupo-l/pwm' -t 'elt73a/lab07/grupo-l/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-l/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-l/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-l/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-l/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-l/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-l/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-m/adc' -t 'elt73a/lab07/grupo-m/pwm' -t 'elt73a/lab07/grupo-m/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-m/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-m/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-m/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-m/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-m/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-m/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-x/adc' -t 'elt73a/lab07/grupo-x/pwm' -t 'elt73a/lab07/grupo-x/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-x/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-x/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-x/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-x/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-x/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-x/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-p/adc' -t 'elt73a/lab07/grupo-p/pwm' -t 'elt73a/lab07/grupo-p/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-p/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-p/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-p/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-p/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-p/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-p/cmd/modo -m pot
1. 1. Assinar tópicos (sem o framebuffer):
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab07/grupo-n/adc' -t 'elt73a/lab07/grupo-n/pwm' -t 'elt73a/lab07/grupo-n/cmd/#' -v | tee /ev/t4-mqtt.txt"
2. 2. Comandar via MQTT:
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-n/cmd/modo -m remoto
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-n/cmd/aquecedor -m 30
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-n/cmd/ventilador -m 80
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-n/cmd/aquecedor -m 150
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-n/cmd/modo -m turbo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t elt73a/lab07/grupo-n/cmd/modo -m pot
Os dois penúltimos comandos são inválidos de propósito: aquecedor 150 está fora da faixa e
turbo não é um modo.
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:
elt73a/lab07/grupo-a/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-a/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-a/cmd/modo remoto
elt73a/lab07/grupo-a/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-a/cmd/aquecedor 30
elt73a/lab07/grupo-a/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-a/cmd/ventilador 80
elt73a/lab07/grupo-a/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-a/cmd/aquecedor 150
elt73a/lab07/grupo-a/cmd/modo turbo
elt73a/lab07/grupo-a/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-b/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-b/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-b/cmd/modo remoto
elt73a/lab07/grupo-b/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-b/cmd/aquecedor 30
elt73a/lab07/grupo-b/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-b/cmd/ventilador 80
elt73a/lab07/grupo-b/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-b/cmd/aquecedor 150
elt73a/lab07/grupo-b/cmd/modo turbo
elt73a/lab07/grupo-b/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-c/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-c/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-c/cmd/modo remoto
elt73a/lab07/grupo-c/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-c/cmd/aquecedor 30
elt73a/lab07/grupo-c/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-c/cmd/ventilador 80
elt73a/lab07/grupo-c/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-c/cmd/aquecedor 150
elt73a/lab07/grupo-c/cmd/modo turbo
elt73a/lab07/grupo-c/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-d/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-d/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-d/cmd/modo remoto
elt73a/lab07/grupo-d/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-d/cmd/aquecedor 30
elt73a/lab07/grupo-d/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-d/cmd/ventilador 80
elt73a/lab07/grupo-d/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-d/cmd/aquecedor 150
elt73a/lab07/grupo-d/cmd/modo turbo
elt73a/lab07/grupo-d/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-e/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-e/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-e/cmd/modo remoto
elt73a/lab07/grupo-e/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-e/cmd/aquecedor 30
elt73a/lab07/grupo-e/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-e/cmd/ventilador 80
elt73a/lab07/grupo-e/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-e/cmd/aquecedor 150
elt73a/lab07/grupo-e/cmd/modo turbo
elt73a/lab07/grupo-e/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-f/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-f/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-f/cmd/modo remoto
elt73a/lab07/grupo-f/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-f/cmd/aquecedor 30
elt73a/lab07/grupo-f/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-f/cmd/ventilador 80
elt73a/lab07/grupo-f/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-f/cmd/aquecedor 150
elt73a/lab07/grupo-f/cmd/modo turbo
elt73a/lab07/grupo-f/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-g/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-g/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-g/cmd/modo remoto
elt73a/lab07/grupo-g/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-g/cmd/aquecedor 30
elt73a/lab07/grupo-g/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-g/cmd/ventilador 80
elt73a/lab07/grupo-g/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-g/cmd/aquecedor 150
elt73a/lab07/grupo-g/cmd/modo turbo
elt73a/lab07/grupo-g/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-h/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-h/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-h/cmd/modo remoto
elt73a/lab07/grupo-h/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-h/cmd/aquecedor 30
elt73a/lab07/grupo-h/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-h/cmd/ventilador 80
elt73a/lab07/grupo-h/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-h/cmd/aquecedor 150
elt73a/lab07/grupo-h/cmd/modo turbo
elt73a/lab07/grupo-h/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-i/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-i/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-i/cmd/modo remoto
elt73a/lab07/grupo-i/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-i/cmd/aquecedor 30
elt73a/lab07/grupo-i/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-i/cmd/ventilador 80
elt73a/lab07/grupo-i/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-i/cmd/aquecedor 150
elt73a/lab07/grupo-i/cmd/modo turbo
elt73a/lab07/grupo-i/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-j/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-j/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-j/cmd/modo remoto
elt73a/lab07/grupo-j/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-j/cmd/aquecedor 30
elt73a/lab07/grupo-j/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-j/cmd/ventilador 80
elt73a/lab07/grupo-j/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-j/cmd/aquecedor 150
elt73a/lab07/grupo-j/cmd/modo turbo
elt73a/lab07/grupo-j/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-k/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-k/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-k/cmd/modo remoto
elt73a/lab07/grupo-k/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-k/cmd/aquecedor 30
elt73a/lab07/grupo-k/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-k/cmd/ventilador 80
elt73a/lab07/grupo-k/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-k/cmd/aquecedor 150
elt73a/lab07/grupo-k/cmd/modo turbo
elt73a/lab07/grupo-k/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-l/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-l/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-l/cmd/modo remoto
elt73a/lab07/grupo-l/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-l/cmd/aquecedor 30
elt73a/lab07/grupo-l/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-l/cmd/ventilador 80
elt73a/lab07/grupo-l/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-l/cmd/aquecedor 150
elt73a/lab07/grupo-l/cmd/modo turbo
elt73a/lab07/grupo-l/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-m/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-m/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-m/cmd/modo remoto
elt73a/lab07/grupo-m/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-m/cmd/aquecedor 30
elt73a/lab07/grupo-m/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-m/cmd/ventilador 80
elt73a/lab07/grupo-m/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-m/cmd/aquecedor 150
elt73a/lab07/grupo-m/cmd/modo turbo
elt73a/lab07/grupo-m/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-x/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-x/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-x/cmd/modo remoto
elt73a/lab07/grupo-x/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-x/cmd/aquecedor 30
elt73a/lab07/grupo-x/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-x/cmd/ventilador 80
elt73a/lab07/grupo-x/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-x/cmd/aquecedor 150
elt73a/lab07/grupo-x/cmd/modo turbo
elt73a/lab07/grupo-x/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-p/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-p/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-p/cmd/modo remoto
elt73a/lab07/grupo-p/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-p/cmd/aquecedor 30
elt73a/lab07/grupo-p/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-p/cmd/ventilador 80
elt73a/lab07/grupo-p/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-p/cmd/aquecedor 150
elt73a/lab07/grupo-p/cmd/modo turbo
elt73a/lab07/grupo-p/cmd/modo pot
elt73a/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:
elt73a/lab07/grupo-n/adc {"raw":3000,"mv":2420,"sp":45.5}
elt73a/lab07/grupo-n/pwm {"modo":"pot","estado":"MANUAL","aq":73,"ve":73,"aq_duty":186,"ve_duty":186,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-n/cmd/modo remoto
elt73a/lab07/grupo-n/pwm {"modo":"remoto","estado":"REMOTO","aq":0,"ve":0,"aq_duty":0,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-n/cmd/aquecedor 30
elt73a/lab07/grupo-n/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":0,"aq_duty":77,"ve_duty":0,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-n/cmd/ventilador 80
elt73a/lab07/grupo-n/pwm {"modo":"remoto","estado":"REMOTO","aq":30,"ve":80,"aq_duty":77,"ve_duty":204,"sp":45.5,"t":24.5}
elt73a/lab07/grupo-n/cmd/aquecedor 150
elt73a/lab07/grupo-n/cmd/modo turbo
elt73a/lab07/grupo-n/cmd/modo pot
elt73a/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: dashboard de comando
O Node-RED desta aula é mínimo: ele mostra a tela e o estado do ESP32 e manda os comandos de modo e de PWM. Registrar cada mudança dos atuadores num banco e calcular tempo e energia fica para o Lab 08.
Na página Lab 07 (caminho /lab07) do My Dashboard, crie dois grupos: ESP32 (OLED) e
Comando (largura 4 cada).
5.1 Tela e status
Copie da aba Lab 06 o mqtt in do framebuffer e o ui-template "OLED pixel a pixel". Troque
o tópico para elt73a/lab07/grupo-x/oled/fb e coloque o template no grupo ESP32 (OLED). Logo
abaixo, um mqtt in .../status (a String) → ui-text "ESP32".
5.2 Estado, modo e sliders
mqtt in elt73a/lab07/grupo-x/pwm (a parsed JSON object) → function com 4 saídas:
// .../pwm -> estado e sincronia dos comandos (só o que mudou)
const p = msg.payload;
if (typeof p?.aq !== "number") return null;
const ant = context.get("ant") || {};
context.set("ant", p);
const mudou = (k) => ant[k] !== p[k];
return [
{ payload: `${p.estado} · AQ ${p.aq} % · VE ${p.ve} %` },
mudou("modo") ? { payload: p.modo } : null, // botões do modo
p.modo === "remoto" && mudou("aq") ? { payload: p.aq } : null, // sliders só no remoto
p.modo === "remoto" && mudou("ve") ? { payload: p.ve } : null,
];
| Saída | Nó |
|---|---|
| 1 | ui-text "Estado" (grupo ESP32 (OLED)) |
| 2 | ui-button-group "Modo" (grupo Comando): opções pot (Potenciômetro) e remoto (Remoto); Topic elt73a/lab07/grupo-x/cmd/modo; pass-through desligado |
| 3, 4 | ui-slider "Aquecedor no remoto (%)" e "Ventilador no remoto (%)": 0–100, passo 5, Topic .../cmd/aquecedor e .../cmd/ventilador, on release, pass-through desligado |
Ligue o button-group e os dois sliders a um mqtt out com tópico vazio, que usa o
msg.topic de cada um.
Os widgets mostram o que o ESP32 confirmou em .../pwm, e não o último clique. Se a function
reenviasse o valor a cada mensagem, um slider que você está arrastando "pularia" de volta. E os
sliders só acompanham o ESP32 no modo remoto: no modo pot, quem manda é o knob.
Com o dashboard aberto em http://localhost:1880/dashboard/lab07:
- clique Remoto e mova os sliders: os LEDs no Wokwi, as barras no OLED e o texto "Estado" 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 captura do dashboard em evidencias/t5-dashboard.png e a aba Lab 07
exportada em nodered/flows-lab07.json.
- ├── 📂nodered
- └── 🔧flows-lab07.json👈 Criar Aqui
- └── 📂evidencias
- └── 📄t5-dashboard.png👈 Criar Aqui
git conferir nodered/flows-lab07.json evidencias/t5-dashboard.png
Node-RED: dashboard de comando
git conferir nodered/flows-lab07.json evidencias/t5-dashboard.png
git add nodered/flows-lab07.json evidencias/t5-dashboard.png && git commit -m "T5: Node-RED: 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: terceira opção Automático no button-group (valor
auto). Nenhum outro nó muda: a function da T5 já repassa qualquer modo confirmado pelo ESP32. - 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-dashboard.png: o dashboard em Automático, com o estadoRESFRIANDO(passo 41,0 °C do experimento).- 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?
(No Lab 08 você vai medir isso no banco: tempo em cada estado e energia do aquecedor.)
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 📂nodered
- └── 🔧flows-lab07.json👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t6-serial.txt👈 Criar Aqui
- └── 📄t6-dashboard.png👈 Criar Aqui
git conferir src/main.cpp nodered/flows-lab07.json evidencias/t6-serial.txt evidencias/t6-dashboard.png
Modo auto: controle ON/OFF com histerese
git conferir src/main.cpp nodered/flows-lab07.json evidencias/t6-serial.txt evidencias/t6-dashboard.png
git add src/main.cpp nodered/flows-lab07.json evidencias/t6-serial.txt evidencias/t6-dashboard.png && 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
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.