Laboratório 04
Checklist — Wi-Fi e MQTT no ESP32
- Projeto PlatformIO com plataforma e PubSubClient em versões fixas,
diagram.jsoncom o LED no GPIO2 ewokwi.toml(T1) - Varredura das redes Wi-Fi no monitor serial (T2)
- Conexão Wi-Fi em modo estação, com IP e RSSI no serial (T3)
- Conexão ao broker público com client ID único (T4)
- Conexão ao broker privado com usuário e senha (T5)
- Telemetria em JSON a cada 2 s, sem
delay()(T6) - Comando
.../cmd/ledligando e desligando o LED, com reconexão de Wi-Fi e MQTT noloop()(T7) - Workflow de CI compilando o firmware a cada
push(T8) - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T8 = 100 pts (esta aula não tem desafios): T1 10 · T2 10 · T3 15 · T4 15 · T5 10 ·
T6 15 · T7 15 · T8 10. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de
cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Até o Lab 03 o ESP32 só falava com o monitor serial. Nesta aula ele entra na rede: conecta ao Wi-Fi, fala com um broker MQTT, publica telemetria e recebe um comando para ligar e desligar um LED. É a base de todos os labs seguintes: do Lab 05 em diante, o mesmo padrão ganha um sensor, um temporizador, o Node-RED e um banco de dados.
Objetivos
- Conectar o ESP32 a uma rede Wi-Fi (modo estação) e obter o IP.
- Conectar-se a um broker MQTT por host e porta, com e sem usuário e senha.
- Publicar dados de telemetria periodicamente em um tópico.
- Assinar um tópico e reagir a comandos recebidos (ligar/desligar um LED).
- Tornar a conexão robusta, com reconexão de Wi-Fi e MQTT no
loop(). - Rodar o mesmo código no simulador Wokwi e no ESP32 físico, entendendo a diferença entre broker público e local.
Material
- 1 × ESP32 (ex.: DevKit v1) ou o simulador Wokwi.
- 1 × LED + resistor de 220 Ω (para o comando remoto).
- Uma rede Wi-Fi (real, para o ESP32 físico; no Wokwi, a
Wokwi-GUEST). - Um broker MQTT:
- Público (para o Wokwi):
broker.hivemq.com:1883. - Privado (para o Wokwi):
mqtt.adrianoruseler.com:1883, com usuário e senha fornecidos pelo professor. - Local (para o ESP32 físico): o Mosquitto do stack Docker do curso, no IP da sua
máquina na rede (ex.:
192.168.0.10:1883). O Wokwi não alcança um broker local.
- Público (para o Wokwi):
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/lab04-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-a/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-a.git && cd lab04-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-b/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-b.git && cd lab04-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-c/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-c.git && cd lab04-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-d/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-d.git && cd lab04-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-e/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-e.git && cd lab04-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-f/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-f.git && cd lab04-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-g/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-g.git && cd lab04-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-h/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-h.git && cd lab04-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-i/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-i.git && cd lab04-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-j/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-j.git && cd lab04-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-k/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-k.git && cd lab04-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-l/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-l.git && cd lab04-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-m/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-m.git && cd lab04-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-x/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-x.git && cd lab04-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-p/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-p.git && cd lab04-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab04-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab04-grupo-n/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-n.git && cd lab04-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab04-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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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\lab04-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-a"
2. Gere o LAB IoT do grupo em docker\lab04-a:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-a-nodered && (del /q "data\lab04-a\flows.json" "data\lab04-a\flows_cred.json" "data\lab04-a\.flows*.backup" 2>nul & docker compose start lab04-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-b"
2. Gere o LAB IoT do grupo em docker\lab04-b:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-b-nodered && (del /q "data\lab04-b\flows.json" "data\lab04-b\flows_cred.json" "data\lab04-b\.flows*.backup" 2>nul & docker compose start lab04-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-c"
2. Gere o LAB IoT do grupo em docker\lab04-c:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-c-nodered && (del /q "data\lab04-c\flows.json" "data\lab04-c\flows_cred.json" "data\lab04-c\.flows*.backup" 2>nul & docker compose start lab04-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-d"
2. Gere o LAB IoT do grupo em docker\lab04-d:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-d-nodered && (del /q "data\lab04-d\flows.json" "data\lab04-d\flows_cred.json" "data\lab04-d\.flows*.backup" 2>nul & docker compose start lab04-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-e"
2. Gere o LAB IoT do grupo em docker\lab04-e:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-e-nodered && (del /q "data\lab04-e\flows.json" "data\lab04-e\flows_cred.json" "data\lab04-e\.flows*.backup" 2>nul & docker compose start lab04-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-f"
2. Gere o LAB IoT do grupo em docker\lab04-f:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-f-nodered && (del /q "data\lab04-f\flows.json" "data\lab04-f\flows_cred.json" "data\lab04-f\.flows*.backup" 2>nul & docker compose start lab04-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-g"
2. Gere o LAB IoT do grupo em docker\lab04-g:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-g-nodered && (del /q "data\lab04-g\flows.json" "data\lab04-g\flows_cred.json" "data\lab04-g\.flows*.backup" 2>nul & docker compose start lab04-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-h"
2. Gere o LAB IoT do grupo em docker\lab04-h:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-h-nodered && (del /q "data\lab04-h\flows.json" "data\lab04-h\flows_cred.json" "data\lab04-h\.flows*.backup" 2>nul & docker compose start lab04-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-i"
2. Gere o LAB IoT do grupo em docker\lab04-i:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-i-nodered && (del /q "data\lab04-i\flows.json" "data\lab04-i\flows_cred.json" "data\lab04-i\.flows*.backup" 2>nul & docker compose start lab04-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-j"
2. Gere o LAB IoT do grupo em docker\lab04-j:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-j-nodered && (del /q "data\lab04-j\flows.json" "data\lab04-j\flows_cred.json" "data\lab04-j\.flows*.backup" 2>nul & docker compose start lab04-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-k"
2. Gere o LAB IoT do grupo em docker\lab04-k:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-k-nodered && (del /q "data\lab04-k\flows.json" "data\lab04-k\flows_cred.json" "data\lab04-k\.flows*.backup" 2>nul & docker compose start lab04-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-l"
2. Gere o LAB IoT do grupo em docker\lab04-l:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-l-nodered && (del /q "data\lab04-l\flows.json" "data\lab04-l\flows_cred.json" "data\lab04-l\.flows*.backup" 2>nul & docker compose start lab04-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-m"
2. Gere o LAB IoT do grupo em docker\lab04-m:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-m-nodered && (del /q "data\lab04-m\flows.json" "data\lab04-m\flows_cred.json" "data\lab04-m\.flows*.backup" 2>nul & docker compose start lab04-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-x"
2. Gere o LAB IoT do grupo em docker\lab04-x:
py "%IOT_GEN%" --disciplina elt73a --lab lab04 --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 lab04-x-nodered && (del /q "data\lab04-x\flows.json" "data\lab04-x\flows_cred.json" "data\lab04-x\.flows*.backup" 2>nul & docker compose start lab04-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Mapa de tarefas — 8 tarefas · 100 pts
- T1 — Projeto PlatformIO e Wokwi · 10 pts
- T2 — Varredura das redes Wi-Fi · 10 pts
- T3 — Conexao Wi-Fi · 15 pts
- T4 — Conexao ao broker MQTT · 15 pts
- T5 — Broker MQTT com usuario e senha · 10 pts
- T6 — Telemetria periodica · 15 pts
- T7 — Comando remoto do LED · 15 pts
- T8 — CI no GitHub Actions · 10 pts
Estrutura de Arquivos do Projeto (no fim da aula)
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- ├── 🔧diagram.json👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Criar Aqui
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Criar Aqui
- └── 📂workflows
- └── 📝README.md👈 Edite Aqui
Tudo fica sob elt73a/lab04/grupo-x/. Troque o x (e o #define GRUPO) pela letra do seu grupo.
| Tópico | Sentido | Payload |
|---|---|---|
.../telemetria | ESP32 → broker | {"n":7,"temp":32.00} (T6) |
.../cmd/led | broker → ESP32 | on/off ou 1/0 (T7) |
Parte 1 — Projeto PlatformIO e Wokwi
Execute os comandos para subir o stack do LAB04!
1.1 Criar o projeto
Na raiz do repositório, como no Lab 02:
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --sample-code
O --sample-code cria um src/main.cpp de exemplo: o projeto já compila no commit da T1, e na T2
você o substitui.
A biblioteca WiFi.h já vem no core do ESP32. Fixe a plataforma (como no Lab 02) e acrescente o
cliente MQTT (PubSubClient), também com versão fixa:
- └── 🔧platformio.ini👈 Criar Aqui
git conferir platformio.ini
[env:esp32dev]
platform = espressif32@6.9.0 ; versão fixa (Lab 02)
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
knolleary/PubSubClient@2.8
1.2 Circuito no Wokwi (LED do comando)
O circuito é o do Lab 02: LED no GPIO2 com um resistor de 220 Ω. Ele só será usado na T7.
- ├── 🔧diagram.json👈 Criar Aqui
- └── 🔧wokwi.toml👈 Criar Aqui
git conferir diagram.json wokwi.toml
- diagram.json
- wokwi.toml
{
"version": 1,
"author": "elt73a - Lab 04",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-resistor",
"id": "r1",
"top": 130,
"left": 120,
"attrs": { "value": "220" }
},
{
"type": "wokwi-led",
"id": "led1",
"top": 80,
"left": 220,
"attrs": { "color": "red", "label": "GPIO2" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["esp:2", "r1:1", "green", []],
["r1:2", "led1:A", "green", []],
["led1:C", "esp:GND.2", "black", []]
],
"dependencies": {}
}
[wokwi]
version = 1
firmware = '.pio/build/esp32dev/firmware.bin'
elf = '.pio/build/esp32dev/firmware.elf'
gdbServerPort = 3333
1.3 Validar o diagrama
O wokwi-cli não fica instalado no Windows: ele roda na imagem Docker que você montou no Lab 02.
Na raiz do repositório:
docker run --rm -v "%cd%:/projeto" -w /projeto elt73a/esp32-dev:lab02 wokwi-cli lint .
Se o Docker responder que a imagem não existe, rode docker compose build na pasta do repositório
do Lab 02 e tente de novo.
Projeto PlatformIO e Wokwi
git conferir platformio.ini src/main.cpp diagram.json wokwi.toml
git add platformio.ini src/main.cpp diagram.json wokwi.toml && git commit -m "T1: Projeto PlatformIO e Wokwi" && 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 — Varredura das redes Wi-Fi
- └── 📂src
- └── 📄main.cpp👈 Criar Aqui
git conferir src/main.cpp
/* ESP32 WiFi Scanning example */
#include <Arduino.h>
#include "WiFi.h"
void setup() {
Serial.begin(115200);
Serial.println("Initializing WiFi...");
WiFi.mode(WIFI_STA);
Serial.println("Setup done!");
}
void loop() {
Serial.println("Scanning...");
// WiFi.scanNetworks will return the number of networks found
int n = WiFi.scanNetworks();
Serial.println("Scan done!");
if (n == 0) {
Serial.println("No networks found.");
} else {
Serial.println();
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i) {
// Print SSID and RSSI for each network found
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*");
delay(10);
}
}
Serial.println("");
// Wait a bit before scanning again
delay(5000);
}
Compile (pio run) e rode Wokwi: Start Simulator: a Wokwi-GUEST aparece na lista.
Varredura das redes Wi-Fi
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T2: Varredura das redes Wi-Fi" && 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 — Conectar ao Wi-Fi
Modo estação (WIFI_STA), WiFi.begin() e espera até WL_CONNECTED.
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#include <Arduino.h>
#include <WiFi.h>
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
// placa física: troque pela rede real
// const char *WIFI_SSID = "IoT-Broker";
// const char *WIFI_SENHA = "ESP32IoTLab";
void conectaWiFi() {
Serial.print("Conectando a "); Serial.println(WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA);
while (WiFi.status() != WL_CONNECTED) {
delay(300);
Serial.print(".");
}
Serial.println();
Serial.print("Conectado! IP: "); Serial.println(WiFi.localIP());
Serial.print("RSSI: "); Serial.println(WiFi.RSSI());
}
void setup() {
Serial.begin(115200);
delay(1000);
conectaWiFi();
}
void loop() {}
Saída esperada (o IP e o RSSI variam):
Conectando a Wokwi-GUEST
....
Conectado! IP: 10.13.37.2
RSSI: -30
Conexao Wi-Fi
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T3: Conexao Wi-Fi" && 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 — Conectar ao broker MQTT
O PubSubClient usa um WiFiClient por baixo. Definimos o servidor e tentamos conectar com um
client id único: dois clientes com o mesmo ID no mesmo broker se derrubam mutuamente.
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
void conectaWiFi() {
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA);
while (WiFi.status() != WL_CONNECTED) { delay(300); Serial.print("."); }
Serial.print("\nWiFi OK, IP: "); Serial.println(WiFi.localIP());
}
void conectaMQTT() {
while (!mqtt.connected()) {
String clientId = "esp32-" + String(random(0xffff), HEX);
Serial.print("Conectando ao broker MQTT... ");
if (mqtt.connect(clientId.c_str())) {
Serial.println("conectado!");
} else {
Serial.print("falhou (rc="); Serial.print(mqtt.state());
Serial.println("), nova tentativa em 2s");
delay(2000);
}
}
}
void setup() {
Serial.begin(115200);
delay(1000);
conectaWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
conectaMQTT();
}
void loop() {
mqtt.loop();
}
Saída esperada:
....
WiFi OK, IP: 10.13.37.2
Conectando ao broker MQTT... conectado!
Se falhar, mqtt.state() dá a pista: -2 = não alcançou o servidor (host/porta errados ou sem
rede), -4 = timeout, 5 = não autorizado. Muito útil para depurar.
Na placa física, troque o SSID e a senha pela rede real e o MQTT_HOST pelo IP da máquina onde
o stack do curso roda (o Mosquitto escuta na porta 1883). O computador e o ESP32 precisam estar
na mesma rede.
Conexao ao broker MQTT
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T4: Conexao ao broker MQTT" && 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 — Broker MQTT com usuário e senha
O broker privado do curso pede usuário e senha. Muda só o connect(), que passa a receber as
credenciais. Use o usuário e a senha fornecidos pelo professor (nunca a senha de uma conta sua).
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
const char *MQTT_HOST = "mqtt.adrianoruseler.com";
const uint16_t MQTT_PORTA = 1883;
// credenciais do broker (fornecidas pelo professor)
const char *MQTT_USER = "seu_usuario";
const char *MQTT_PASS = "sua_senha";
// em conectaMQTT():
if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
Saída esperada: a mesma da T4. Com a senha errada, o rc é 5 (não autorizado).
Broker MQTT com usuario e senha
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T5: Broker MQTT com usuario e senha" && 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.
Parte 6 — Publicar telemetria
Publique uma mensagem a cada 2 s, sem delay() bloqueante (usando millis(), como no Lab 02).
Use o código da T4 (broker público) e acrescente o tópico, trocando o grupo pelo seu:
const char *TOPICO_TELEMETRIA = "elt73a/lab04/grupo-a/telemetria"; // troque 'grupo-a'!
E use este loop():
void loop() {
if (!mqtt.connected()) conectaMQTT();
mqtt.loop();
static unsigned long ultimo = 0;
if (millis() - ultimo >= 2000) {
ultimo = millis();
static int n = 0;
n++;
float temp = 25.0 + (n % 10); // leitura simulada
char payload[64];
snprintf(payload, sizeof(payload), "{\"n\":%d,\"temp\":%.2f}", n, temp);
mqtt.publish(TOPICO_TELEMETRIA, payload);
Serial.print("Publicado: "); Serial.println(payload);
}
}
Saída esperada (a cada 2 s):
Publicado: {"n":1,"temp":26.00}
Publicado: {"n":2,"temp":27.00}
Publicado: {"n":3,"temp":28.00}
Veja as mensagens chegando no MQTT Explorer do stack (http://localhost:3000, conectado a
broker.hivemq.com:1883) ou pelo terminal:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-b/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-c/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-d/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-e/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-f/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-g/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-h/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-i/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-j/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-k/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-l/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-m/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-x/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-p/#" -v
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-n/#" -v
Telemetria periodica
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T6: Telemetria periodica" && 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.
Parte 7 — Comando remoto do LED
Agora o ESP32 também assina um tópico. Quando chega uma mensagem, o PubSubClient chama uma
função sua (o callback) dentro do mqtt.loop(). Dois cuidados:
- o payload não termina com
'\0': copie para um buffer e termine a string antes de comparar; - assine dentro de
conectaMQTT(): a sessão é limpa, então depois de uma reconexão o broker não lembra das assinaturas antigas.
E a conexão fica robusta: o loop() confere o Wi-Fi e o MQTT a cada volta e reconecta o que caiu.
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#define GRUPO "a" // troque pela letra do seu grupo
#define LED_PIN 2
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;
const char *TOPICO_TELEMETRIA = "elt73a/lab04/grupo-" GRUPO "/telemetria";
const char *TOPICO_CMD_LED = "elt73a/lab04/grupo-" GRUPO "/cmd/led";
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
// chamada pelo PubSubClient, dentro de mqtt.loop(), a cada mensagem num tópico assinado
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[8];
size_t n = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, n);
txt[n] = '\0'; // o payload não termina em '\0'
Serial.printf("[CMD] %s <- '%s'\r\n", topico, txt);
if (strcmp(txt, "on") == 0 || strcmp(txt, "1") == 0) {
digitalWrite(LED_PIN, HIGH);
} else if (strcmp(txt, "off") == 0 || strcmp(txt, "0") == 0) {
digitalWrite(LED_PIN, LOW);
} else {
Serial.println("[CMD] use on/off ou 1/0");
}
}
void conectaWiFi() {
Serial.print("Conectando a "); Serial.println(WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA);
while (WiFi.status() != WL_CONNECTED) { delay(300); Serial.print("."); }
Serial.print("\nWiFi OK, IP: "); Serial.println(WiFi.localIP());
}
void conectaMQTT() {
while (!mqtt.connected()) {
String clientId = "esp32-" + String(random(0xffff), HEX);
Serial.print("Conectando ao broker MQTT... ");
if (mqtt.connect(clientId.c_str())) {
Serial.println("conectado!");
mqtt.subscribe(TOPICO_CMD_LED); // (re)assina a cada conexão
} else {
Serial.print("falhou (rc="); Serial.print(mqtt.state());
Serial.println("), nova tentativa em 2s");
delay(2000);
}
}
}
void setup() {
Serial.begin(115200);
delay(1000);
pinMode(LED_PIN, OUTPUT);
conectaWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
conectaMQTT();
}
void loop() {
if (WiFi.status() != WL_CONNECTED) conectaWiFi(); // reconexão do Wi-Fi
if (!mqtt.connected()) conectaMQTT(); // reconexão do MQTT
mqtt.loop();
static unsigned long ultimo = 0;
if (millis() - ultimo >= 2000) {
ultimo = millis();
static int n = 0;
n++;
float temp = 25.0 + (n % 10); // leitura simulada
char payload[64];
snprintf(payload, sizeof(payload), "{\"n\":%d,\"temp\":%.2f}", n, temp);
mqtt.publish(TOPICO_TELEMETRIA, payload);
Serial.print("Publicado: "); Serial.println(payload);
}
}
Com a simulação rodando, mande os comandos pelo terminal e veja o LED no Wokwi:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-b/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-b/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-b/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-c/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-c/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-c/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-d/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-d/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-d/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-e/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-e/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-e/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-f/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-f/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-f/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-g/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-g/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-g/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-h/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-h/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-h/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-i/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-i/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-i/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-j/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-j/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-j/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-k/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-k/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-k/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-l/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-l/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-l/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-m/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-m/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-m/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-x/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-x/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-x/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-p/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-p/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-p/cmd/led" -m talvez
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-n/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-n/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-n/cmd/led" -m talvez
Publicado: {"n":7,"temp":32.00}
[CMD] elt73a/lab04/grupo-a/cmd/led <- 'on'
Publicado: {"n":8,"temp":33.00}
[CMD] elt73a/lab04/grupo-a/cmd/led <- 'off'
[CMD] elt73a/lab04/grupo-a/cmd/led <- 'talvez'
[CMD] use on/off ou 1/0
Comando remoto do LED
git conferir src/main.cpp
git add src/main.cpp && git commit -m "T7: Comando remoto do LED" && 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 T7.
Parte 8 — CI no GitHub Actions
Um workflow que compila o firmware a cada push. Se o código parar de compilar, a execução fica
vermelha na aba Actions. O Lab 10 completa este pipeline com testes, simulação e release.
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Criar Aqui
- └── 📂workflows
- ├── 📄...
- └── 📂src
- └── 📄main.cpp
git conferir .github/workflows/ci.yml
name: CI
on: [push, pull_request]
env:
PLATFORMIO_VERSAO: "6.2.0" # versão fixa, como a plataforma no platformio.ini
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-python@v7
with:
python-version: "3.12"
- name: Cache do PlatformIO
uses: actions/cache@v6
with:
path: |
~/.platformio
~/.cache/pip
key: pio-${{ runner.os }}-${{ env.PLATFORMIO_VERSAO }}-${{ hashFiles('platformio.ini') }}
- name: Instala o PlatformIO
run: pip install "platformio==${PLATFORMIO_VERSAO}"
- name: Compila o firmware
run: pio run
ci.yml?O nome ci.yml é o mesmo do Lab 10 e não se confunde com o workflow do autograder que vem no
template do repositório. Não apague nem renomeie os arquivos que já estão em .github/.
CI no GitHub Actions
git conferir .github/workflows/ci.yml
git add .github/workflows/ci.yml && git commit -m "T8: CI no GitHub Actions" && 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 T8.
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.