Laboratório 12
Checklist — depuração com GDB no Wokwi for VS Code
- Firmware em
lab12,wokwi.tomlcomgdbServerPort,.vscode/launch.json"Wokwi GDB" e a primeira sessão parada emapp_main(T1) - Breakpoints (simples, condicional e de função), passo a passo, variáveis, Watch e uma variável mudada com o firmware parado (T2)
- Memória e FreeRTOS pelo GDB:
x,print/x, a fila de eventos, a task de cada núcleo e a pilha daapp(T3) - As três falhas do Lab 11 ao vivo: o panic parado antes do reboot, o
div0evitado e otravardestravado sem reiniciar (T4) - O mesmo firmware em
-Os: o que o depurador deixa de mostrar (T5) - O defeito da média móvel achado com um watchpoint, corrigido e verificado (T6)
- Previsões P1–P5 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 15 · 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
Até aqui, para saber o que o firmware estava fazendo, você tinha três ferramentas: um
ESP_LOGI a mais (e um build a mais), os testes do Lab 10 e, depois de um crash, os endereços do
Guru Meditation decodificados à mão no Lab 11. Todas olham de fora e depois.
Nesta aula você entra dentro do firmware enquanto ele roda. O Wokwi tem um servidor GDB: com ele, o VS Code para o ESP32 simulado numa linha, mostra as variáveis e a pilha de chamadas, avança uma instrução por vez, muda um valor na memória e deixa o firmware seguir. É o mesmo GDB que, numa placa real, conversaria com o chip por JTAG.
Objetivos
- Configurar o Wokwi for VS Code como alvo de depuração (
gdbServerPort,launch.json, extensão C/C++) e conectar o GDB do toolchain do ESP-IDF. - Usar breakpoints (de linha, condicionais, de função), passo a passo (
step,next,finish,stepi), a pilha de chamadas, os painéis Variables e Watch e o Debug Console (-exec). - Ler a memória e o estado do FreeRTOS pelo GDB: a fila de eventos, a task de cada núcleo, a pilha.
- Depurar um crash antes do reboot e mudar o estado do programa para contorná-lo.
- Entender o que a otimização tira do depurador.
- Achar um defeito de corrupção de memória com um watchpoint.
Material
- VS Code + PlatformIO + Wokwi for VS Code (com a licença que você já usa) + extensão
C/C++ da Microsoft (
ms-vscode.cpptools), que é quem fala com o GDB. - O GDB do Xtensa. Desde o GCC 12, a Espressif distribui o GDB separado do compilador, e a
plataforma
espressif32@7.1.0comframework = espidfjá o instala junto do build, no pacotetool-xtensa-esp-elf-gdb(versão 12.1 no Linux e no macOS, 11.2 no Windows). Nada para baixar. - O circuito de sempre, com o
diagram.jsonque já passa nowokwi-cli lint(Lab 10). mosquitto_pub/mosquitto_subvia Docker, como nos labs anteriores.
A documentação do Wokwi para PlatformIO aponta para
~/.platformio/packages/toolchain-xtensa-esp32/bin/xtensa-esp32-elf-gdb. Esse é o toolchain
antigo (GCC 8, usado pelo Arduino), que trazia o GDB dentro dele. O nosso firmware usa o
toolchain novo (toolchain-xtensa-esp-elf, GCC 15), que não tem GDB: ele está em
~/.platformio/packages/tool-xtensa-esp-elf-gdb/. Confira se a pasta existe:
dir "%USERPROFILE%\.platformio\packages" | findstr gdb
dir "%USERPROFILE%\.platformio\packages\tool-xtensa-esp-elf-gdb\bin"
No Linux e no macOS: ls ~/.platformio/packages/ | grep gdb e
ls ~/.platformio/packages/tool-xtensa-esp-elf-gdb/bin/.
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/lab12-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-a/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-a.git && cd lab12-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-b/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-b.git && cd lab12-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-c/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-c.git && cd lab12-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-d/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-d.git && cd lab12-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-e/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-e.git && cd lab12-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-f/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-f.git && cd lab12-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-g/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-g.git && cd lab12-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-h/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-h.git && cd lab12-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-i/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-i.git && cd lab12-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-j/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-j.git && cd lab12-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-k/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-k.git && cd lab12-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-l/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-l.git && cd lab12-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-m/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-m.git && cd lab12-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-x/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-x.git && cd lab12-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-p/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-p.git && cd lab12-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab12-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab12-grupo-n/commits/main/
- Acessos: ACESSO-LAB12.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/lab12-grupo-n.git && cd lab12-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab12-grupo-n" && code . --profile "ESP32IO"
Envie o link do repositório do seu grupo no Moodle:
lab12 ainda não tem cmid configurado em src/data/labassigns.json.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\lab12-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-a"
2. Gere o LAB IoT do grupo em docker\lab12-a:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo a --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 lab12-a-nodered && (del /q "data\lab12-a\flows.json" "data\lab12-a\flows_cred.json" "data\lab12-a\.flows*.backup" 2>nul & docker compose start lab12-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-b"
2. Gere o LAB IoT do grupo em docker\lab12-b:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo b --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 lab12-b-nodered && (del /q "data\lab12-b\flows.json" "data\lab12-b\flows_cred.json" "data\lab12-b\.flows*.backup" 2>nul & docker compose start lab12-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-c"
2. Gere o LAB IoT do grupo em docker\lab12-c:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo c --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 lab12-c-nodered && (del /q "data\lab12-c\flows.json" "data\lab12-c\flows_cred.json" "data\lab12-c\.flows*.backup" 2>nul & docker compose start lab12-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-d"
2. Gere o LAB IoT do grupo em docker\lab12-d:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo d --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 lab12-d-nodered && (del /q "data\lab12-d\flows.json" "data\lab12-d\flows_cred.json" "data\lab12-d\.flows*.backup" 2>nul & docker compose start lab12-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-e"
2. Gere o LAB IoT do grupo em docker\lab12-e:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo e --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 lab12-e-nodered && (del /q "data\lab12-e\flows.json" "data\lab12-e\flows_cred.json" "data\lab12-e\.flows*.backup" 2>nul & docker compose start lab12-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-f"
2. Gere o LAB IoT do grupo em docker\lab12-f:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo f --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 lab12-f-nodered && (del /q "data\lab12-f\flows.json" "data\lab12-f\flows_cred.json" "data\lab12-f\.flows*.backup" 2>nul & docker compose start lab12-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-g"
2. Gere o LAB IoT do grupo em docker\lab12-g:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo g --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 lab12-g-nodered && (del /q "data\lab12-g\flows.json" "data\lab12-g\flows_cred.json" "data\lab12-g\.flows*.backup" 2>nul & docker compose start lab12-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-h"
2. Gere o LAB IoT do grupo em docker\lab12-h:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo h --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 lab12-h-nodered && (del /q "data\lab12-h\flows.json" "data\lab12-h\flows_cred.json" "data\lab12-h\.flows*.backup" 2>nul & docker compose start lab12-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-i"
2. Gere o LAB IoT do grupo em docker\lab12-i:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo i --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 lab12-i-nodered && (del /q "data\lab12-i\flows.json" "data\lab12-i\flows_cred.json" "data\lab12-i\.flows*.backup" 2>nul & docker compose start lab12-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-j"
2. Gere o LAB IoT do grupo em docker\lab12-j:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo j --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 lab12-j-nodered && (del /q "data\lab12-j\flows.json" "data\lab12-j\flows_cred.json" "data\lab12-j\.flows*.backup" 2>nul & docker compose start lab12-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-k"
2. Gere o LAB IoT do grupo em docker\lab12-k:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo k --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 lab12-k-nodered && (del /q "data\lab12-k\flows.json" "data\lab12-k\flows_cred.json" "data\lab12-k\.flows*.backup" 2>nul & docker compose start lab12-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-l"
2. Gere o LAB IoT do grupo em docker\lab12-l:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo l --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 lab12-l-nodered && (del /q "data\lab12-l\flows.json" "data\lab12-l\flows_cred.json" "data\lab12-l\.flows*.backup" 2>nul & docker compose start lab12-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-m"
2. Gere o LAB IoT do grupo em docker\lab12-m:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo m --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 lab12-m-nodered && (del /q "data\lab12-m\flows.json" "data\lab12-m\flows_cred.json" "data\lab12-m\.flows*.backup" 2>nul & docker compose start lab12-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab12-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab12-x"
2. Gere o LAB IoT do grupo em docker\lab12-x:
py "%IOT_GEN%" --disciplina elt73a --lab lab12 --grupo x --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 lab12-x-nodered && (del /q "data\lab12-x\flows.json" "data\lab12-x\flows_cred.json" "data\lab12-x\.flows*.backup" 2>nul & docker compose start lab12-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Conectar o GDB ao Wokwi · 10 pts
- T2 — Breakpoints, passos e variaveis · 20 pts
- T3 — Memoria e FreeRTOS pelo GDB · 15 pts
- T4 — As falhas do Lab 11 ao vivo · 20 pts
- T5 — Depurando codigo otimizado · 15 pts
- T6 — Caca ao defeito com watchpoint · 20 pts
O repositório nasce do lab12-template: o firmware final do Lab 11 (ESP-IDF, com a bancada
e as falhas, ainda com os textos em lab11) e duas mudanças pequenas:
src/filtro.c: uma média móvel das 4 últimas leituras do DHT22, publicada comot_mediano.../dht. Ela tem um defeito, que você vai caçar na T6.src/falhas.c: o laço docmd/falha travaragora éwhile (!liberar). Nenhuma linha do firmware mudaliberar: só o depurador (T4).
Estrutura de Arquivos do Projeto
- ├── 🔧platformio.ini👈 Verificar
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 📄sdkconfig.defaults👈 Verificar
- ├── 📄merge_firmware.py👈 Verificar
- ├── 📄disasm.py👈 Verificar
- ├── 🔧wokwi.toml👈 Edite Aqui
- ├── 🔧diagram.json👈 Verificar
- ├── 📄.gitignore👈 Edite Aqui
- ├── 📂.vscode
- ├── 🔧launch.json👈 Criar Aqui
- └── 🔧extensions.json👈 Criar Aqui
- ├── 📂src
- ├── 📄config.h👈 Edite Aqui
- ├── 📄main.c👈 Edite Aqui
- ├── 📄filtro.h👈 Verificar
- ├── 📄filtro.c👈 Edite Aqui
- ├── 📄falhas.c👈 Verificar
- ├── 📄bancada.c👈 Verificar
- └── 📄rede.c👈 Verificar
- ├── 📂components
- ├── 📄dht22👈 Verificar
- └── 📄gfx👈 Verificar
- ├── 📂evidencias
- ├── 📄t1-conexao.png👈 Criar Aqui
- ├── 📄t1-console.txt👈 Criar Aqui
- ├── 📝t2-depuracao.md👈 Criar Aqui
- ├── 📄t3-memoria.txt👈 Criar Aqui
- ├── 📝t4-falhas.md👈 Criar Aqui
- ├── 📝t5-otimizado.md👈 Criar Aqui
- ├── 📝t6-filtro.md👈 Criar Aqui
- └── 📄t6-watchpoint.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Os mesmos do Lab 11, sob elt73a/lab12/grupo-x/. O .../dht ganha o campo t_media:
{"grupo":"a","seq":7,"t":24.5,"t_media":24.5,"h":55.0,...}.
As sessões de GDB mostradas aqui foram gravadas com o mesmo firmware rodando no QEMU da Espressif (que também tem servidor GDB), com a rede desligada. No Wokwi, os endereços, os tempos e a lista de threads podem ser outros. O que vale são os nomes das funções, as linhas e os valores das variáveis.
Parte 1 — Conectar o GDB ao Wokwi
Execute os comandos para subir o stack do LAB12!
1.1 Firmware no Lab 12
Como nos labs anteriores: em src/ use Ctrl+H com Match Case ligado e troque lab11 →
lab12, LAB11 → LAB12 e Lab 11 → Lab 12. No CMakeLists.txt da raiz, project(lab11) →
project(lab12). Compile (pio run) e rode no Wokwi como sempre, para conferir que nada quebrou.
1.2 Três arquivos
O simulador abre o servidor GDB numa porta TCP:
[wokwi]
version = 1
# framework = espidf: a imagem completa (gerada pelo merge_firmware.py), não só o app
firmware = '.pio/build/esp32dev/firmware.merged.bin'
elf = '.pio/build/esp32dev/firmware.elf'
# Lab 12: o simulador abre um servidor GDB nesta porta (o launch.json conecta nela)
gdbServerPort = 3333
O VS Code precisa saber qual GDB usar, qual ELF carregar (é dele que saem os nomes e as linhas) e onde está o servidor:
{
// Lab 12: depurar o firmware que roda no Wokwi.
// 1) pio run 2) F1 > "Wokwi: Start Simulator and Wait for Debugger" 3) F5 com "Wokwi GDB"
"version": "0.2.0",
"configurations": [
{
"name": "Wokwi GDB",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/.pio/build/esp32dev/firmware.elf",
"cwd": "${workspaceFolder}",
"MIMode": "gdb",
"miDebuggerServerAddress": "localhost:3333",
"linux": {
"miDebuggerPath": "${userHome}/.platformio/packages/tool-xtensa-esp-elf-gdb/bin/xtensa-esp32-elf-gdb",
},
"osx": {
"miDebuggerPath": "${userHome}/.platformio/packages/tool-xtensa-esp-elf-gdb/bin/xtensa-esp32-elf-gdb",
},
"windows": {
"miDebuggerPath": "${userHome}/.platformio/packages/tool-xtensa-esp-elf-gdb/bin/xtensa-esp32-elf-gdb.exe",
},
},
],
}
{
"recommendations": [
"platformio.platformio-ide",
"wokwi.wokwi-vscode",
"ms-vscode.cpptools"
]
}
Desde o Lab 09, o .gitignore do template ignora a pasta .vscode/, porque o PlatformIO com ESP-IDF
gera nela arquivos que mudam de um computador para outro. Ficam de fora dessa regra o
settings.json do Lab 01 (o terminal cmd) e, agora, a configuração de depuração, que precisa ir
para o repositório como no Lab 02 (o colega clona e já depura):
.pio/
# .vscode/ fica fora do repositório, menos a configuração de depuração (Lab 12)
.vscode/*
!.vscode/settings.json
!.vscode/launch.json
!.vscode/extensions.json
managed_components/
sdkconfig.esp32dev
sdkconfig.esp32dev.old
wokwi.vcd
# dependencies.lock VAI para o repositório: fixa as versões dos componentes baixados
O PlatformIO também escreve configurações no launch.json (as "PIO Debug"). Elas são para
depurar uma placa real por JTAG (um ESP-Prog, por exemplo) e não funcionam com o Wokwi.
Deixe-as no arquivo e escolha "Wokwi GDB" no seletor da aba Run and Debug. Se a sua
configuração sumir depois de mexer no platformio.ini, cole-a de novo.
1.3 A primeira sessão
A ordem importa: o simulador abre o servidor, e só então o GDB pode conectar.
pio run(o ELF precisa estar atualizado: o GDB lê as linhas dele, não do seu.c).- F1 → Wokwi: Start Simulator and Wait for Debugger. O simulador abre, mas fica parado.
- Abra
src/main.ce clique à esquerda do número da linha devoid app_main(void): aparece um ponto vermelho (breakpoint). - F5 (com "Wokwi GDB" selecionado). O VS Code conecta, o firmware dá boot e para em
app_main.
Repare no painel Call Stack: app_main foi chamada por main_task, que foi chamada por
vPortTaskWrapper. É o mecanismo que o Lab 09 descreveu ("quem chama o app_main?"), agora
visível. A barra de controle tem Continue (F5), Step Over (F10), Step Into (F11),
Step Out (Shift+F11), Pause (F6), Restart e Stop.
O Debug Console (aba ao lado do Terminal) aceita comandos do GDB, com o prefixo -exec:
-exec info threads
-exec bt
-exec info registers pc
-exec info breakpoints
Thread 1 hit Breakpoint 1, app_main () at src/main.c:413
#0 app_main () at src/main.c:413
#1 0x400d5298 in main_task (args=0x0) at $IDF_PATH/components/freertos/app_startup.c:206
#2 0x400eaafc in vPortTaskWrapper (pxCode=0x400d5234 <main_task>, pvParameters=0x0) at $IDF_PATH/components/freertos/FreeRTOS-Kernel/portable/xtensa/port.c:147
Id Target Id Frame
* 1 Thread 1.1 (CPU#0 [running]) app_main () at src/main.c:413
2 Thread 1.2 (CPU#1 [halted ]) 0x4008565e in esp_cpu_wait_for_intr () at $IDF_PATH/components/esp_hw_support/cpu.c:64
Por fim, acrescente temporariamente "stopAtConnect": true à configuração, reinicie (passos 2 e 4) e veja onde o processador está antes de qualquer código seu: anote o pc. Depois, tire a
linha.
P1: (a) com stopAtConnect, em que endereço o processador está quando o GDB conecta? Em que
região do mapa do Lab 11 fica esse endereço, e quem escreveu o código que está lá? (b) Por que o
simulador precisa ser iniciado antes do F5? E por que um ELF desatualizado faz o depurador
parar "na linha errada"? (c) Quantas threads o info threads mostra? Elas são as tasks do
FreeRTOS ou outra coisa? Anote o que o Wokwi mostra (pode ser diferente do QEMU).
Evidências: evidencias/t1-conexao.png (o VS Code parado em app_main, com o Call Stack
visível) e evidencias/t1-console.txt (a saída dos quatro comandos do Debug Console e o pc do
stopAtConnect).
- ├── 🔧wokwi.toml👈 Edite Aqui
- ├── 📂.vscode
- ├── 🔧launch.json👈 Criar Aqui
- └── 🔧extensions.json👈 Criar Aqui
- ├── 📄.gitignore👈 Edite Aqui
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 📂src
- ├── 📄config.h👈 Edite Aqui
- └── 📄main.c👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t1-conexao.png👈 Criar Aqui
- └── 📄t1-console.txt👈 Criar Aqui
git conferir wokwi.toml .vscode/launch.json .vscode/extensions.json .gitignore CMakeLists.txt src/config.h src/main.c evidencias/t1-conexao.png evidencias/t1-console.txt
Conectar o GDB ao Wokwi
git conferir wokwi.toml .vscode/launch.json .vscode/extensions.json .gitignore CMakeLists.txt src/config.h src/main.c evidencias/t1-conexao.png evidencias/t1-console.txt
git add wokwi.toml .vscode/launch.json .vscode/extensions.json .gitignore CMakeLists.txt src/config.h src/main.c evidencias/t1-conexao.png evidencias/t1-console.txt && git commit -m "T1: Conectar o GDB ao 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 — Breakpoints, passos e variáveis
2.1 O mapa: painel, botão ou comando
Tudo o que a interface faz é um comando do GDB por baixo. Quando a interface não oferecer algo, use o Debug Console.
| Quero... | No VS Code | No Debug Console |
|---|---|---|
| parar numa linha | clique na margem da linha | -exec break main.c:278 |
| parar numa função (sem abrir o arquivo) | Breakpoints ▸ + (Add Function Breakpoint) | -exec break esp_panic_handler |
| parar só às vezes | botão direito no ponto ▸ Edit Breakpoint ▸ Expression | -exec condition 2 ev.tipo == EV_COMANDO |
| executar a linha sem entrar na função | Step Over (F10) | -exec next |
| entrar na função | Step Into (F11) | -exec step |
| terminar a função e voltar | Step Out (Shift+F11) | -exec finish |
| uma instrução de máquina | Disassembly View ▸ F11 | -exec stepi |
| ver uma expressão sempre | painel Watch ▸ + | -exec display setpoint |
| mudar uma variável | Variables ▸ duplo clique no valor | -exec set var modo = MODO_AUTO |
| ver a memória crua | — | -exec x/7xw &filtro_dht |
2.2 Dois caminhos até ler_adc
Ponha um breakpoint na primeira linha de ler_adc() e dê Continue (F5) até ele parar duas
vezes. Em cada parada, olhe o Call Stack e a thread selecionada.
Thread 1 hit Breakpoint 1, ler_adc () at src/main.c:122
#0 ler_adc () at src/main.c:122
#1 0x400db8a8 in app_main () at src/main.c:429
[Switching to Thread 1.2]
Thread 2 hit Breakpoint 1, ler_adc () at src/main.c:122
#0 ler_adc () at src/main.c:122
#1 0x400db6c3 in task_app (arg=0x0) at src/main.c:363
#2 0x400eaafc in vPortTaskWrapper (pxCode=0x400db684 <task_app>, pvParameters=0x0) at .../port.c:147
Na segunda parada: Step Over até a linha do float sp = ..., abra o painel Variables e
procure sp; passe o mouse sobre adc_raw e adc_mv; dê Step Out e veja setpoint. No
painel Watch, acrescente:
setpoint
NOME_MODO[modo]
adc_raw * 100 / 4095
filtro_dht
2.3 Mudar o firmware sem recompilar
Com o firmware parado, mude modo para MODO_AUTO (duplo clique em Variables, ou
-exec set var modo = MODO_AUTO) e dê Continue. Quando o DHT22 for lido, o controlar() vai
decidir pelo modo auto, sem nenhum cmd/modo. Confira no serial ([PWM] {"modo":"auto",...})
e na tela.
2.4 Breakpoint condicional e de função
- Em
task_app(), ponha um breakpoint na linha doswitch (ev.tipo)com a condiçãoev.tipo == EV_COMANDO. Ele ignora os 10 eventos de ADC por segundo e só para num comando. Mande umcmd/modo pote, parado, olheev.topicoeev.textono Variables. - Acrescente um breakpoint de função em
controlar(Breakpoints ▸ +). Gire o potenciômetro no Wokwi com o firmware rodando e veja quem chamou (Call Stack).
- 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/lab12/grupo-a/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-b/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-c/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-d/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-e/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-f/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-g/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-h/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-i/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-j/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-k/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-l/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-m/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-x/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-p/cmd/modo" -m pot
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-n/cmd/modo" -m pot
2.5 Uma instrução por vez
Pare em atuadores_duty() (o potenciômetro, no modo pot, chega lá) e abra a Disassembly
View (botão direito no editor ▸ Open Disassembly View). Avance com F11 uma instrução por
vez até o callx8 do __divsf3, e compare com a listagem que você anotou na T2 do Lab 11. No
Debug Console:
-exec x/6i $pc
-exec info registers a2 a10 a11
-exec info registers f0 f1
P2: (a) Por que a primeira parada em ler_adc vem do app_main, na CPU 0, e as seguintes da
task_app, na CPU 1? (b) Em -Og (o padrão do ESP-IDF), sp aparece como <optimized out>.
Onde o valor dela está de verdade? (Volte ao ler_adc do app.lst.) (c) Deixe o firmware
parado num breakpoint por um minuto, com o mosquitto_sub aberto em .../status. O que o
broker publica, e depois de quantos segundos? O que acontece quando você dá Continue? (d) Numa
placa real, um breakpoint dentro de dht22_ler() estragaria a leitura do sensor. Por quê? E no
Wokwi?
Evidência: evidencias/t2-depuracao.md com o bt das duas paradas em ler_adc, o valor de
sp, adc_raw, adc_mv e setpoint, a linha do [PWM] depois do set var modo, o
ev.topico e o ev.texto do breakpoint condicional, o Call Stack do breakpoint em controlar e
o x/6i $pc com os registradores da 2.5.
- └── 📂evidencias
- └── 📝t2-depuracao.md👈 Criar Aqui
git conferir evidencias/t2-depuracao.md
Breakpoints, passos e variaveis
git conferir evidencias/t2-depuracao.md
git add evidencias/t2-depuracao.md && git commit -m "T2: Breakpoints, passos e variaveis" && 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 — Memória e FreeRTOS pelo GDB
O GDB conhece os tipos de tudo o que foi compilado com -g, inclusive as estruturas internas
do FreeRTOS. Com um cast, dá para olhar dentro de um QueueHandle_t, que para o seu código é só um
ponteiro opaco. Pare em ler_e_publicar() (na segunda leitura do DHT22) e rode no Debug Console:
-exec print *(Queue_t *) fila
-exec print pxCurrentTCBs[0]->pcTaskName
-exec print pxCurrentTCBs[1]->pcTaskName
-exec print/x pxCurrentTCBs[1]->pxStack
-exec print/x pxCurrentTCBs[1]->pxEndOfStack
-exec print/x $sp
-exec x/7xw &filtro_dht
-exec print filtro_dht
-exec x/s NOME_MODO[2]
-exec x/4i 0x4000c44c
-exec info registers lbeg lend lcount
$1 = {pcHead = 0x3ffb9ca4 "\001", ..., uxMessagesWaiting = 0, uxLength = 16, uxItemSize = 84, ...}
$2 = "IDLE0\000\000\000\000\000\000\000\000\000\000"
$3 = "app", '\000' <repeats 12 times>
$4 = 0x3ffba288
$5 = 0x3ffbba80
$6 = 0x3ffbb960
0x3ffb427c <filtro_dht>: 0x41c40000 0x00000000 0x00000000 0x00000000
0x3ffb428c <filtro_dht+16>: 0x41c40000 0x00000001 0x00000001
$7 = {amostras = {24.5, 0, 0, 0}, soma = 24.5, pos = 1, n = 1}
0x3f404314: "auto"
0x4000c44c: entry a1, 16
0x4000c44f: extui a3, a3, 0, 8
pxCurrentTCBs[n]é a task que está rodando na CPUn(o TCB, task control block, guarda o nome, a pilha, a prioridade...).- A pilha da
appvai depxStackapxEndOfStacke cresce para baixo:pxEndOfStack − $spé o quanto está em uso agora, nessa linha. x/7xwmostra 7 palavras de 32 bits em hexadecimal.0x41c40000é ofloat24,5 (confira com ostruct.unpackdo Lab 11).
P3: (a) Explique o uxLength = 16 e o uxItemSize = 84 da fila (Labs 09 e 11). Quanto vale
o uxMessagesWaiting durante um cmd/falha travar? (b) Calcule o tamanho da pilha da app
(pxEndOfStack − pxStack) e o uso naquele instante (pxEndOfStack − $sp). Bate com o
xTaskCreatePinnedToCore e com o pilha_livre_app do .../diag (Lab 09)? (c) O x/4i 0x4000c44c mostra o código do memset, que não está no seu ELF (é ROM, Lab 11). De onde o GDB
o leu? (d) LBEG, LEND e LCOUNT são os registradores da instrução loop (Lab 11, T5). Por
que eles apontam para a ROM?
Evidência: evidencias/t3-memoria.txt com a saída dos onze comandos e as contas da P3(b).
- └── 📂evidencias
- └── 📄t3-memoria.txt👈 Criar Aqui
git conferir evidencias/t3-memoria.txt
Memoria e FreeRTOS pelo GDB
git conferir evidencias/t3-memoria.txt
git add evidencias/t3-memoria.txt && git commit -m "T3: Memoria e FreeRTOS pelo GDB" && 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 — As falhas do Lab 11 ao vivo
No Lab 11, você só via o crash depois: o Guru Meditation, o reboot e os endereços para decodificar. Com o depurador conectado, dá para parar antes do reboot, e até evitar o crash.
- 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/lab12/grupo-a/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-b/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-c/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-d/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-e/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-f/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-g/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-h/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-i/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-j/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-k/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-l/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-m/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-x/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-p/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab12/grupo-n/cmd/falha" -m nulo
4.1 nulo: parar dentro do panic
O panic handler do ESP-IDF só entrega o controle ao depurador sozinho se detectar um depurador
JTAG no chip. Com o servidor GDB de um simulador, não conte com isso: ponha você mesmo um
breakpoint de função em esp_panic_handler e mande o cmd/falha nulo.
Thread 2 hit Breakpoint 2, esp_panic_handler (info=0x3ffbb810) at .../esp_system/panic.c:324
#0 esp_panic_handler (info=0x3ffbb810) at .../esp_system/panic.c:324
#1 0x400d32e6 in panic_handler (frame=0x3ffbb810, pseudo_excause=false) at .../port/panic_handler.c:264
#2 0x40081967 in xt_unhandled_exception (frame=0x3ffbb810) at .../port/panic_handler.c:307
#3 0x40082ebb in _xt_handle_exc () at .../xtensa/xtensa_vectors.S:830
#4 0x400e70a7 in guardar_setpoint (l=0x0, sp=0) at src/falhas.c:33
#5 0x400dc0d0 in falhas_provocar (tipo=0x3ffbb9b4 "nulo") at src/falhas.c:52
#6 0x400db404 in tratar_comando (topico=0x3ffbb974 "elt73a/lab12/grupo-a/cmd/falha", txt=0x3ffbb9b4 "nulo") at src/main.c:324
#7 0x400db795 in task_app (arg=0x0) at src/main.c:388
O GDB atravessa a exceção e mostra a pilha inteira, inclusive os argumentos de tratar_comando
(o tópico e o texto do comando). Mas não confie nos argumentos de guardar_setpoint no quadro
#4: sp=0 está errado (o programa gravava 37,5), e numa outra execução o l também saiu com
lixo. Naquele ponto a janela de registradores foi salva pela exceção, e o GDB não sabe onde. Os valores verdadeiros estão na XtExcFrame, a estrutura que o vetor de
exceção preencheu. Clique no quadro panic_handler do Call Stack e:
-exec print/x *(XtExcFrame *) frame
-exec x/i ((XtExcFrame *) frame)->pc
$3 = {exit = 0x3ffbb8d0, pc = 0x400e70a7, ps = 0x60230, a0 = 0x800dc0d0, a1 = 0x3ffbb8d0, a2 = 0x0, a3 = 0x42160000, ..., exccause = 0x1d, excvaddr = 0x8, lbeg = 0x400012e5, lend = 0x40001309, lcount = 0x800dc0b2, ...}
0x400e70a7 <guardar_setpoint+3>: s32i.n a3, a2, 8
É o mesmo conteúdo que o Guru Meditation vai imprimir quando você der Continue. Confira.
4.2 div0: evitar o crash
Ponha um breakpoint em media() e mande cmd/falha div0. Olhe os argumentos.
Thread 2 hit Breakpoint 1, media (soma=1061176952, n=1061175468) at src/falhas.c:38
Lixo de novo, e não é a exceção: o breakpoint caiu na própria instrução entry, antes de a
janela de registradores girar (Lab 11, T2). Os argumentos ainda estão em a10/a11 do chamador. Dê
um stepi e olhe de novo: agora soma = 1234 e n = 0. Então:
-exec stepi
-exec info args
-exec set var n = 2
-exec info args
Remova o breakpoint e dê Continue. No serial aparece I (...) falhas: media = 617, e o ESP32
não reinicia.
Se você fizer o set var n = 2 antes do stepi, o GDB escreve no registrador errado, a
divisão acontece com n = 0 e o crash vem do mesmo jeito. No Xtensa, só confie nos argumentos
depois do entry.
4.3 travar: destravar sem reiniciar
Mande cmd/falha travar e espere aparecer o task_wdt e a enxurrada de fila cheia. Agora:
- Pause (F6). A CPU pode parar dentro de um vetor de interrupção (o tick do FreeRTOS roda 1000 vezes por segundo), e aí o Call Stack fica curto. Não se preocupe.
- Ponha um breakpoint na linha
while (!liberar) voltas++;e dê Continue: ele para na hora, porque a CPU 1 não sai dali. - Olhe
voltase a fila (-exec print ((Queue_t *) fila)->uxMessagesWaiting). -exec set var liberar = 1, remova o breakpoint e dê Continue.
A task app sai do laço, processa os 16 eventos que estavam na fila e volta a publicar. O
task_wdt para de reclamar. Nada reiniciou.
P4: (a) Por que o GDB mostra sp=0 em guardar_setpoint, mas a XtExcFrame mostra
a3 = 0x42160000? Qual dos dois é o valor que o programa usou, e quanto ele vale em float? (b) Por que o set var n = 2 só funciona
depois do stepi? (c) O GDB tem um comando return que tira uma função da pilha. Por que este lab
usa uma variável liberar em vez de return? (Dica: lembre o que a janela de registradores
precisa desfazer.) (d) Com o firmware parado no breakpoint do travar, o watchdog não
reclama. Por quê?
Evidência: evidencias/t4-falhas.md com, para cada falha: os comandos que você usou, o bt e
o que mudou no serial. Para o nulo, inclua a XtExcFrame e o Guru Meditation que veio depois.
- └── 📂evidencias
- └── 📝t4-falhas.md👈 Criar Aqui
git conferir evidencias/t4-falhas.md
As falhas do Lab 11 ao vivo
git conferir evidencias/t4-falhas.md
git add evidencias/t4-falhas.md && git commit -m "T4: As falhas do Lab 11 ao vivo" && 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 — Depurando código otimizado
O ESP-IDF compila com -Og justamente para o depurador funcionar. Para ver por quê, compile o
mesmo firmware com -Os, como na T5 do Lab 11: acrescente ao sdkconfig.defaults, apague o
sdkconfig.esp32dev e compile.
CONFIG_COMPILER_OPTIMIZATION_SIZE=y
Repita, em -Os, quatro coisas que você fez em -Og:
- o breakpoint em
ler_adce o Step Over linha a linha (a seta pula? volta?); - o breakpoint de função em
tratar_comando(essa função ainda existe nofirmware.sym?); - um breakpoint na linha
f->pos++;dofiltro.c; - o painel Variables em
ler_e_publicar(quantas variáveis aparecem<optimized out>?).
O próprio GDB conta o que aconteceu com cada linha e cada variável:
-exec info line filtro.c:17
-exec info scope ler_e_publicar
-exec info breakpoints
# -Og
Line 17 of "src/filtro.c" starts at address 0x400de4da <filtro_adicionar+58> and ends at 0x400de4de <filtro_adicionar+62>.
# -Os
Line 17 of "src/filtro.c" is at address 0x400dc876 <filtro_adicionar+46> but contains no code.
No fim, volte ao -Og: tire a linha do sdkconfig.defaults, apague o sdkconfig.esp32dev
e compile. A T6 precisa do -Og.
P5 (parte 1): (a) Em -Os, a função tratar_comando não existe mais no firmware.sym
(Lab 11), e mesmo assim o breakpoint de função funciona. Como? (b) O que significa "contains no
code" para a linha 17, e onde foi parar o f->pos++? (c) Você depura em -Og e entrega em
-Os. Que tipo de defeito pode aparecer só na versão entregue? (Lembre o esperar() e o
nulo do Lab 11.)
Evidência: evidencias/t5-otimizado.md com uma tabela "o que eu fiz × o que vi em -Og × o
que vi em -Os" para os quatro itens, e a saída dos três comandos nos dois níveis.
- └── 📂evidencias
- └── 📝t5-otimizado.md👈 Criar Aqui
git conferir evidencias/t5-otimizado.md
Depurando codigo otimizado
git conferir evidencias/t5-otimizado.md
git add evidencias/t5-otimizado.md && git commit -m "T5: Depurando codigo otimizado" && 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 — caça ao defeito com watchpoint
O filtro.c do template tem um defeito. Com o DHT22 parado em 24,5 °C (o valor inicial do
diagrama), o .../dht mostra:
{"grupo":"a","seq":1,"t":24.5,"t_media":24.5,...}
{"grupo":"a","seq":2,"t":24.5,"t_media":24.5,...}
{"grupo":"a","seq":3,"t":24.5,"t_media":24.5,...}
{"grupo":"a","seq":4,"t":24.5,"t_media":24.5,...}
{"grupo":"a","seq":5,"t":24.5,"t_media":12.2,...}
{"grupo":"a","seq":6,"t":24.5,"t_media":12.2,...}
A média de quatro leituras iguais a 24,5 não pode ser 12,2. E nenhuma linha de código faz
soma = ... com metade de nada. Alguém está escrevendo onde não devia.
A ferramenta: watchpoint
Um watchpoint para o programa quando um endereço de memória muda, seja qual for a linha que escreveu. O ESP32 tem dois comparadores de endereço no hardware para isso, e o GDB os usa (hardware watchpoint). Um breakpoint pergunta "quando esta linha roda?"; um watchpoint pergunta "quem mexeu nesta variável?".
-exec watch filtro_dht.soma
(No VS Code também dá para clicar com o botão direito numa variável do painel Variables e escolher Break When Value Changes.)
Requisitos
-
Reproduza o sintoma no Wokwi (deixe 6 leituras passarem) e anote o
seqem quet_mediaerrou. -
Prenda o defeito: reinicie a sessão, pare em
app_main, crie o watchpoint emfiltro_dht.somae dê Continue a cada parada. Em cada uma, anote o valor antigo, o novo, a linha ef->pos. Ache a parada em quesomamuda numa linha que não deveria escrever nela. -
Prove o mecanismo com o GDB:
Debug Console (parado no filtro_adicionar)-exec print *f-exec print &f->amostras[4]-exec print &f->soma-exec ptype filtro_t -
Corrija o
filtro.c(uma linha) e verifique com o mesmo watchpoint: agorasomasó muda nas linhas certas, e ot_mediado.../dhtfica certo também com temperaturas diferentes (mexa no DHT22 do Wokwi). -
Evidências:
evidencias/t6-filtro.mdcom a tabela das paradas (antes e depois da correção), a saída dos comandos do item 3 e a explicação em três frases;evidencias/t6-watchpoint.pngcom o VS Code parado no watchpoint que entrega o defeito.
Hardware watchpoint 2: filtro_dht.soma
Old value = 0
New value = 24.5
filtro_adicionar (f=0x3ffb427c <filtro_dht>, x=24.5) at src/filtro.c:17
...
Old value = 100.100006
New value = 141.100006
filtro_adicionar (f=0x3ffb427c <filtro_dht>, x=41) at src/filtro.c:17
O watchpoint para na linha seguinte à que escreveu: o hardware avisa depois da gravação.
O watchpoint de hardware depende do servidor GDB do simulador. Se o Wokwi recusar o watch (ou o
GDB disser que usou um software watchpoint, que avança instrução por instrução e fica lento
demais), use um breakpoint condicional na linha f->amostras[f->pos] = x; com a condição
f->pos >= FILTRO_N, e registre no t6-filtro.md qual dos dois caminhos você usou.
P5 (parte 2): (a) Antes do watchpoint: em que leitura (seq) e em que linha você aposta
que soma é estragada? (b) O defeito escreve fora do vetor e o ESP32 não trava. Por quê? Que
outro membro da struct seria estragado se soma estivesse declarada depois de pos? (c) Que
teste unitário, no estilo do Lab 10, teria pegado esse defeito antes de ele chegar ao firmware?
- ├── 📂src
- └── 📄filtro.c👈 Edite Aqui
- ├── 📂evidencias
- ├── 📝t6-filtro.md👈 Criar Aqui
- └── 📄t6-watchpoint.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir src/filtro.c evidencias/t6-filtro.md evidencias/t6-watchpoint.png README.md
Caca ao defeito com watchpoint
git conferir src/filtro.c evidencias/t6-filtro.md evidencias/t6-watchpoint.png README.md
git add src/filtro.c evidencias/t6-filtro.md evidencias/t6-watchpoint.png README.md && git commit -m "T6: Caca ao defeito com watchpoint" && 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.