Laboratório 11
Checklist — o assembly do ESP32: ver, ler e medir
- Firmware do Lab 09 em
lab11, com odisasm.pygerandofirmware.lst,app.lst,firmware.symefirmware.secoes, e os.sdo compilador (T1) - Anatomia de três funções Xtensa: janela de registradores,
l32r, FPU e chamadas a__divsf3(T2) - Mapa da memória: em que região (ROM, IRAM, flash, DRAM) fica cada símbolo, e o efeito do
IRAM_ATTR(T3) - Bancada de ciclos (
cmd/bancada→.../bancada), com cada resultado explicado pelo assembly (T4) - Níveis de otimização:
exemplos/otimizacao.cde-O0a-O2,volatile, e o firmware inteiro em-Og,-Ose-O2(T5) - Três falhas (
cmd/falha nulo | div0 | travar) diagnosticadas pelo PC, pelos registradores e peloaddr2line(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
No Lab 09 você escreveu o firmware em C com as APIs do ESP-IDF, e no Lab 10 passou a verificar o
comportamento dele por máquina: testes unitários, wokwi-cli e CI. Falta olhar o que fica
entre o código e o teste: o que o compilador gerou. Quem executa não é o C, é uma sequência de
instruções Xtensa que o compilador escolheu por você, e um teste verde não diz quanto ela
custa nem o que o compilador apagou. Nesta aula o firmware
não ganha funções novas. Você abre o binário, lê o que o GCC gerou e mede o que cada escolha
custa:
- por que
setpoint / 2vira uma multiplicação, masadc_raw / 4095.0fvira uma chamada de função? - onde fica cada coisa:
app_main,memset, oNOME_MODO, a variávelseq, a pilha da task? - quanto custa um
float× umdouble× umsnprintf("%.1f")? - o que muda entre
-Og,-Ose-O2, e por que um laçowhile (!pronto)pode virar um laço infinito? - e, quando o ESP32 reinicia com um Guru Meditation, como sair do endereço
0x400e717baté a linha do C que causou o crash?
O Lab 10 usou o firmware Arduino (o do Lab 08), porque o pio test no ESP32 é mais direto
nele. Esta aula volta ao firmware ESP-IDF do Lab 09: tudo o que ela mede depende dele (o nível
de otimização no sdkconfig, o esp_idf_size, o IRAM_ATTR, o Guru Meditation do IDF). O que
veio do Lab 10 continua valendo: o diagram.json do template já passa no wokwi-cli lint, e a T5
e a T6 voltam ao pipeline para perguntar o que o CI deixaria passar.
Objetivos
- Gerar e navegar a desmontagem do firmware (
objdump), a tabela de símbolos (nm) e o assembly do compilador (-save-temps,-fverbose-asm). - Ler código Xtensa LX6: janela de registradores (
entry,call8,retw), constantes porl32r, a FPU de precisão simples e as funções de biblioteca que substituem o que o hardware não tem. - Localizar cada símbolo no mapa de memória do ESP32 e entender o que
IRAM_ATTReconstmudam. - Medir com o contador de ciclos (
CCOUNT) e justificar cada número com as instruções. - Comparar níveis de otimização e reconhecer o que o compilador pode apagar (
volatile, comportamento indefinido). - Diagnosticar um crash pelo PC, pelos registradores e pelo backtrace.
Material
- VS Code + PlatformIO + extensão Wokwi, com o circuito de sempre (o
diagram.jsonjá sem ochannelNamesque owokwi-cli lintdo Lab 10 acusa). - O toolchain que o Lab 09 já instalou (
toolchain-xtensa-esp-elf, GCC 15.2):objdump,nm,addr2linee o própriogcc. Nada para baixar. mosquitto_sub/mosquitto_pubvia Docker, como nos labs anteriores.- Python 3 com o pacote
esp-idf-size(py -m pip install esp-idf-size), na T1 e na T3. - Opcional: o Compiler Explorer tem compiladores "Xtensa ESP32" para testar trechos isolados.
O PlatformIO não coloca o toolchain no PATH do terminal. Use o pio pkg exec, que acha o
executável dentro do pacote (funciona igual no Linux, no macOS e no Windows):
pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-objdump --version
Nesta aula, objdump, nm, addr2line e gcc são sempre xtensa-esp32-elf-... chamados
assim. Para encurtar, o enunciado escreve só $XT objdump ...: leia como pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-objdump ....
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/lab11-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-a/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-a.git && cd lab11-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-b/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-b.git && cd lab11-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-c/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-c.git && cd lab11-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-d/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-d.git && cd lab11-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-e/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-e.git && cd lab11-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-f/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-f.git && cd lab11-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-g/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-g.git && cd lab11-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-h/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-h.git && cd lab11-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-i/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-i.git && cd lab11-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-j/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-j.git && cd lab11-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-k/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-k.git && cd lab11-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-l/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-l.git && cd lab11-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-m/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-m.git && cd lab11-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-x/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-x.git && cd lab11-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-p/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-p.git && cd lab11-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab11-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab11-grupo-n/commits/main/
- Acessos: ACESSO-LAB11.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/lab11-grupo-n.git && cd lab11-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab11-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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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 11:
- 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\lab11-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-a"
2. Gere o LAB IoT do grupo em docker\lab11-a:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-a-nodered && (del /q "data\lab11-a\flows.json" "data\lab11-a\flows_cred.json" "data\lab11-a\.flows*.backup" 2>nul & docker compose start lab11-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-b"
2. Gere o LAB IoT do grupo em docker\lab11-b:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-b-nodered && (del /q "data\lab11-b\flows.json" "data\lab11-b\flows_cred.json" "data\lab11-b\.flows*.backup" 2>nul & docker compose start lab11-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-c"
2. Gere o LAB IoT do grupo em docker\lab11-c:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-c-nodered && (del /q "data\lab11-c\flows.json" "data\lab11-c\flows_cred.json" "data\lab11-c\.flows*.backup" 2>nul & docker compose start lab11-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-d"
2. Gere o LAB IoT do grupo em docker\lab11-d:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-d-nodered && (del /q "data\lab11-d\flows.json" "data\lab11-d\flows_cred.json" "data\lab11-d\.flows*.backup" 2>nul & docker compose start lab11-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-e"
2. Gere o LAB IoT do grupo em docker\lab11-e:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-e-nodered && (del /q "data\lab11-e\flows.json" "data\lab11-e\flows_cred.json" "data\lab11-e\.flows*.backup" 2>nul & docker compose start lab11-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-f"
2. Gere o LAB IoT do grupo em docker\lab11-f:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-f-nodered && (del /q "data\lab11-f\flows.json" "data\lab11-f\flows_cred.json" "data\lab11-f\.flows*.backup" 2>nul & docker compose start lab11-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-g"
2. Gere o LAB IoT do grupo em docker\lab11-g:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-g-nodered && (del /q "data\lab11-g\flows.json" "data\lab11-g\flows_cred.json" "data\lab11-g\.flows*.backup" 2>nul & docker compose start lab11-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-h"
2. Gere o LAB IoT do grupo em docker\lab11-h:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-h-nodered && (del /q "data\lab11-h\flows.json" "data\lab11-h\flows_cred.json" "data\lab11-h\.flows*.backup" 2>nul & docker compose start lab11-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-i"
2. Gere o LAB IoT do grupo em docker\lab11-i:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-i-nodered && (del /q "data\lab11-i\flows.json" "data\lab11-i\flows_cred.json" "data\lab11-i\.flows*.backup" 2>nul & docker compose start lab11-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-j"
2. Gere o LAB IoT do grupo em docker\lab11-j:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-j-nodered && (del /q "data\lab11-j\flows.json" "data\lab11-j\flows_cred.json" "data\lab11-j\.flows*.backup" 2>nul & docker compose start lab11-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-k"
2. Gere o LAB IoT do grupo em docker\lab11-k:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-k-nodered && (del /q "data\lab11-k\flows.json" "data\lab11-k\flows_cred.json" "data\lab11-k\.flows*.backup" 2>nul & docker compose start lab11-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-l"
2. Gere o LAB IoT do grupo em docker\lab11-l:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-l-nodered && (del /q "data\lab11-l\flows.json" "data\lab11-l\flows_cred.json" "data\lab11-l\.flows*.backup" 2>nul & docker compose start lab11-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-m"
2. Gere o LAB IoT do grupo em docker\lab11-m:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-m-nodered && (del /q "data\lab11-m\flows.json" "data\lab11-m\flows_cred.json" "data\lab11-m\.flows*.backup" 2>nul & docker compose start lab11-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab11-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab11-x"
2. Gere o LAB IoT do grupo em docker\lab11-x:
py "%IOT_GEN%" --disciplina elt73a --lab lab11 --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 lab11-x-nodered && (del /q "data\lab11-x\flows.json" "data\lab11-x\flows_cred.json" "data\lab11-x\.flows*.backup" 2>nul & docker compose start lab11-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Gerar e navegar o assembly · 10 pts
- T2 — Anatomia de uma funcao Xtensa · 20 pts
- T3 — Onde mora cada coisa · 15 pts
- T4 — Bancada de ciclos · 20 pts
- T5 — Niveis de otimizacao e volatile · 15 pts
- T6 — Diagnostico de falhas pelo assembly · 20 pts
O repositório nasce do lab11-template, que traz o firmware final do Lab 09 (ESP-IDF, com NVS
e diagnóstico, ainda com os textos em lab09) e o circuito:
Estrutura de Arquivos do Projeto
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 📄sdkconfig.defaults👈 Verificar
- ├── 📄merge_firmware.py👈 Verificar
- ├── 📄disasm.py👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Verificar
- ├── 🔧diagram.json👈 Verificar
- ├── 📄.gitignore👈 Verificar
- ├── 📂src
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 🚀idf_component.yml👈 Verificar
- ├── 📄config.h👈 Edite Aqui
- ├── 📄main.c👈 Edite Aqui
- ├── 📄rede.c👈 Edite Aqui
- ├── 📄rede.h👈 Verificar
- ├── 📄sensores.c👈 Verificar
- ├── 📄atuadores.c👈 Verificar
- ├── 📄tela.c👈 Verificar
- ├── 📄bancada.h👈 Criar Aqui
- ├── 📄bancada.c👈 Criar Aqui
- ├── 📄falhas.h👈 Criar Aqui
- └── 📄falhas.c👈 Criar Aqui
- ├── 📂components
- ├── 📄dht22👈 Verificar
- └── 📄gfx👈 Verificar
- ├── 📂exemplos
- └── 📄otimizacao.c👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t1-tamanhos.txt👈 Criar Aqui
- ├── 📝t2-anatomia.md👈 Criar Aqui
- ├── 📝t3-memoria.md👈 Criar Aqui
- ├── 📄t4-bancada.txt👈 Criar Aqui
- ├── 📝t4-analise.md👈 Criar Aqui
- ├── 📝t5-otimizacao.md👈 Criar Aqui
- └── 📝t6-falhas.md👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Os mesmos do Lab 09, sob elt73a/lab11/grupo-x/, e mais três:
| Tópico | Direção | Conteúdo | Tarefa |
|---|---|---|---|
.../cmd/bancada | → ESP32 | qualquer texto: roda a bancada de ciclos | T4 |
.../bancada | ESP32 → | JSON com os ciclos de cada operação | T4 |
.../cmd/falha | → ESP32 | nulo, div0 ou travar: provoca uma falha de propósito | T6 |
Todas as listagens deste enunciado vêm de um build real do Lab 11 com o ESP-IDF 6.1. Mas basta
uma linha diferente no código (ou outra letra de grupo) para os endereços mudarem. Use os números
daqui como referência de formato e trabalhe sempre com os do seu firmware.lst.
Parte 1 — Gerar e navegar o assembly
Execute os comandos para subir o stack do LAB11!
1.1 Firmware no Lab 11
Como no Lab 08, só os textos mudam. Em src/ use Ctrl+H com Match Case ligado: lab09 →
lab11 (o LAB do config.h, o namespace da NVS e o client_id), LAB09 → LAB11 (a tela e o
espelho em texto) e Lab 09 → Lab 11 (o banner do serial). No CMakeLists.txt da raiz, troque
project(lab09) por project(lab11).
1.2 Três jeitos de ver o assembly
| O quê | Quem gera | Quando usar |
|---|---|---|
.s do compilador | gcc -S (aqui: -save-temps=obj) | ver o que o GCC escreveu antes do linker: nomes das variáveis nos comentários (-fverbose-asm), endereços ainda simbólicos |
| desmontagem do ELF | objdump -d -S | ver o que vai rodar: endereços finais, bytes de cada instrução, o C intercalado |
| símbolos | nm -S --size-sort | saber onde e quanto ocupa cada função e variável |
O platformio.ini ganha duas coisas: os .s (só para o src/, com build_src_flags) e um
segundo script que roda depois de cada build:
[env:esp32dev]
platform = espressif32@7.1.0
board = esp32dev
framework = espidf
monitor_speed = 115200
monitor_filters = esp32_exception_decoder
; depois do build: a imagem do Wokwi (Lab 09) e a desmontagem (Lab 11)
extra_scripts =
post:merge_firmware.py
post:disasm.py
; Lab 11: guarda o .i (pré-processado) e o .s (assembly comentado) de cada arquivo do src/
build_src_flags =
-save-temps=obj
-fverbose-asm
# disasm.py — Lab 11: depois de cada build, gera a desmontagem e os símbolos do firmware.
#
# firmware.lst tudo: objdump -d -S -C (assembly intercalado com o C), ~18 MB
# app.lst só as funções do src/ (é este que você vai ler)
# firmware.sym símbolos do maior para o menor: endereço, tamanho, tipo, nome
# firmware.secoes as seções do ELF (objdump -h): onde fica cada região da memória
#
# Tudo em .pio/build/esp32dev/. Também roda fora do PlatformIO, para testar:
# python disasm.py firmware.elf pasta-com-os-.o-do-src [prefixo-do-toolchain]
import glob
import os
import re
import subprocess
import sys
CABECALHO = re.compile(r"^([0-9a-f]{8}) <(.+)>:$")
def funcoes_do_src(nm, objetos):
"""Nomes das funções (T ou t) definidas nos objetos do src/."""
nomes = set()
for obj in objetos:
saida = subprocess.run([nm, "--defined-only", obj], capture_output=True, text=True).stdout
for linha in saida.splitlines():
partes = linha.split()
if len(partes) == 3 and partes[1] in ("T", "t"):
nomes.add(partes[2])
return nomes
def gerar(prefixo, elf, objetos, saida_dir):
objdump, nm = prefixo + "objdump", prefixo + "nm"
lst = os.path.join(saida_dir, "firmware.lst")
with open(lst, "w") as f:
subprocess.run([objdump, "-d", "-S", "-C", elf], stdout=f, check=True)
# app.lst: corta o firmware.lst nos cabeçalhos "400dce24 <ler_adc>:" e fica com as do src/
nomes = funcoes_do_src(nm, objetos)
blocos, atual, manter = [], [], False
with open(lst) as f:
for linha in f:
m = CABECALHO.match(linha.rstrip("\n"))
if m:
if manter:
blocos.append("".join(atual))
atual, manter = [], m.group(2) in nomes
elif linha.startswith("Disassembly of section"):
if manter:
blocos.append("".join(atual))
atual, manter = [], False
continue
atual.append(linha)
if manter:
blocos.append("".join(atual))
with open(os.path.join(saida_dir, "app.lst"), "w") as f:
f.write("\n".join(blocos))
# símbolos com tamanho, do maior para o menor (sem os marcadores do linker, como _rtc_*_length)
simbolos = subprocess.run([nm, "-C", "-S", "--size-sort", "-r", elf],
capture_output=True, text=True, check=True).stdout.splitlines()
with open(os.path.join(saida_dir, "firmware.sym"), "w") as f:
f.write("# endereço tamanho tipo nome (t/T = código, d/D = dados com valor, b/B = zerados)\n")
for linha in simbolos:
partes = linha.split(maxsplit=3)
if len(partes) == 4 and int(partes[1], 16) < 0x100000:
f.write(linha + "\n")
with open(os.path.join(saida_dir, "firmware.secoes"), "w") as f:
subprocess.run([objdump, "-h", elf], stdout=f, check=True)
print("disasm.py: %d funções do src/ em app.lst; firmware.lst, .sym e .secoes em %s"
% (len(blocos), saida_dir))
try:
Import("env") # noqa: F821 (dentro do PlatformIO)
except NameError:
env = None
if env is None: # linha de comando
elf, pasta = sys.argv[1], sys.argv[2]
prefixo = sys.argv[3] if len(sys.argv) > 3 else "xtensa-esp32-elf-"
objs = glob.glob(os.path.join(pasta, "**", "*.o*"), recursive=True)
gerar(prefixo, elf, objs, os.path.dirname(os.path.abspath(elf)))
else:
def pos_build(source, target, env):
elf = str(target[0])
build = env.subst("$BUILD_DIR")
# $CC = "xtensa-esp32-elf-gcc": o objdump e o nm têm o mesmo prefixo
prefixo = env.subst("$CC")[: -len("gcc")]
caminho = env.WhereIs(prefixo + "objdump")
if caminho:
prefixo = caminho[: -len("objdump")]
# objetos do src/: .pio/build/esp32dev/src/*.o
objs = glob.glob(os.path.join(build, "src", "**", "*.o"), recursive=True)
gerar(prefixo, elf, objs, build)
env.AddPostAction("$BUILD_DIR/${PROGNAME}.elf", pos_build) # noqa: F821
$OBJCOPY não é o objcopyNo merge_firmware.py do Lab 09, $OBJCOPY é o esptool.py: a plataforma espressif32 usa
esse nome para outra coisa. Por isso o disasm.py monta o nome do objdump a partir do $CC
(xtensa-esp32-elf-gcc → xtensa-esp32-elf-objdump).
Compile (pio run). No fim aparece disasm.py: 42 funções do src/ em app.lst ... (66 depois da
T6, com a bancada e as falhas). Os arquivos ficam em .pio/build/esp32dev/; os .s, ao lado dos objetos, em
.pio/build/esp32dev/src/ (main.c.s, rede.c.s, ...).
1.3 Navegando
Abra o app.lst no VS Code e procure (Ctrl+F) por <ler_adc>:. Cada linha de assembly tem
três colunas: endereço, bytes da instrução (2 ou 3 bytes) e instrução. As linhas sem
endereço são o seu C, que o -S intercalou:
400dcaec <ao_timer>:
static void ao_timer(void *arg) { enfileirar((tipo_evento_t)(intptr_t)arg); }
400dcaec: 004136 entry a1, 32
400dcaef: 02ad mov.n a10, a2
400dcaf1: fffa65 call8 400dca98 <enfileirar>
400dcaf4: f01d retw.n
Agora abra .pio/build/esp32dev/src/main.c.s e procure por ler_adc:. É o mesmo código antes
do linker: em vez de endereços há rótulos (.LC91, call8 __divsf3), e o -fverbose-asm comenta
cada instrução com o nome das variáveis do C:
# .../src/main.c:122: float sp = SP_MIN + adc_raw * (SP_MAX - SP_MIN) / 4095.0f;
l32r a8, .LC91 #, tmp65
l32i.n a8, a8, 0 # adc_raw, adc_raw
float.s f0, a8, 0 # _2, adc_raw
l32r a11, .LC93 #,
l32r a8, .LC92 #, tmp67
wfr f1, a8 # tmp67, tmp67
mul.s f0, f0, f1 # tmp66, _2, tmp67
rfr a10, f0 #, tmp66
call8 __divsf3 #
Para uma função só, direto do ELF:
pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-objdump -d -S --disassemble=ler_adc .pio/build/esp32dev/firmware.elf
1.4 O que ocupa o firmware
O firmware.sym lista os símbolos do maior para o menor. Os primeiros quase nunca são seus:
400d0020 00002920 T _stext
401034ac 000012d4 t esp_internal_sha1_parallel_engine_process$isra$0
4011c5fc 0000122f T hostap_recv_mgmt
400f3b84 000010ea T mbedtls_ssl_handshake_server_step
3ffb7258 00000f88 B g_cnxMgr
40130074 00000dc4 T ieee80211_sta_new_state
Para somar por biblioteca, use o esp-idf-size sobre o arquivo .map que o linker do ESP-IDF
gera (procure-o com dir .pio\build\esp32dev\*.map):
py -m pip install esp-idf-size
py -m esp_idf_size .pio/build/esp32dev/lab11.map
py -m esp_idf_size --archives .pio/build/esp32dev/lab11.map
P1: (a) o app tem ~965 KB. Antes de rodar o --archives, estime quantos KB são do seu
src/ e quais bibliotecas vêm no topo. Depois confira. (b) O firmware.elf tem ~9,6 MB e o
firmware.bin, ~965 KB. O que está no ELF que não vai para a flash? (Olhe o firmware.secoes.)
(c) Compare o ler_adc no main.c.s e no app.lst. O que um mostra que o outro não mostra?
Evidência: em evidencias/t1-tamanhos.txt: as últimas linhas do pio run (RAM e Flash); do
firmware.secoes, as linhas de .iram0.text, .dram0.data, .dram0.bss, .flash.rodata e
.flash.text; as 15 primeiras linhas do firmware.sym; e as 10 primeiras bibliotecas do
--archives, mais a linha da biblioteca do src/.
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📄CMakeLists.txt👈 Edite Aqui
- ├── 📄disasm.py👈 Criar Aqui
- ├── 📂src
- ├── 📄config.h👈 Edite Aqui
- └── 📄main.c👈 Edite Aqui
- └── 📂evidencias
- └── 📄t1-tamanhos.txt👈 Criar Aqui
git conferir platformio.ini CMakeLists.txt disasm.py src/config.h src/main.c evidencias/t1-tamanhos.txt
Gerar e navegar o assembly
git conferir platformio.ini CMakeLists.txt disasm.py src/config.h src/main.c evidencias/t1-tamanhos.txt
git add platformio.ini CMakeLists.txt disasm.py src/config.h src/main.c evidencias/t1-tamanhos.txt && git commit -m "T1: Gerar e navegar o assembly" && 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 — Anatomia de uma função Xtensa
2.1 O mínimo para ler Xtensa
O ESP32 tem dois núcleos Xtensa LX6 de 32 bits. São 64 registradores de uso geral, mas uma
função só enxerga 16 deles, de a0 a a15: é a janela de registradores. A cada call8, a
janela anda 8 posições. O que o chamador escreveu em a10 aparece para a função chamada como
a2:
| Instrução | O que faz |
|---|---|
entry a1, N | primeira instrução de toda função: reserva N bytes de pilha |
retw.n | volta ao chamador e desfaz a janela. O valor de retorno sai em a2 e o chamador o recebe em a10 |
call8 X / callx8 a8 | chama X (direto) ou o endereço que está em a8 (para longe: IRAM, ROM, outro trecho da flash) |
l32r aN, ... | carrega uma constante de 32 bits de uma tabela (literal pool). O objdump mostra o valor entre parênteses |
l32i / s32i / l8ui / s8i | lê / grava 32 bits ou 8 bits na memória: l32i a8, a9, 4 lê o endereço a9 + 4 |
memw | barreira de memória: o compilador a põe antes de todo acesso a uma variável volatile |
mull / quos | multiplicação / divisão inteira com sinal, no hardware |
wfr / rfr | copia um registrador inteiro para um registrador da FPU (f0…f15) e vice-versa |
lsi / ssi | lê / grava um float direto na FPU |
add.s / mul.s / madd.s | soma / multiplicação / multiplica-e-soma em float (precisão simples) |
float.s | converte inteiro → float |
.n no fim (mov.n, l32i.n) | a mesma instrução em 2 bytes em vez de 3: o compilador usa sempre que cabe |
Os tipos têm tamanho fixo no Xtensa: int, long e ponteiros têm 4 bytes, e uint32_t é
unsigned long (é a P2 do Lab 10). Por isso o mesmo l32i/s32i lê e grava todos eles.
A FPU do ESP32 faz float de 32 bits, mas não tem instrução de divisão e não faz double.
O compilador troca essas operações por chamadas a funções da libgcc: __divsf3 (divisão
float), __muldf3 e __divdf3 (double), __extendsfdf2 (float → double). Na listagem,
uma operação do C que vira callx8 em vez de uma instrução é um sinal de custo.
2.2 Lendo atuadores_duty()
A função do Lab 09 que converte 0–100 % em duty de 0–255:
400dde30 <atuadores_duty>:
uint32_t atuadores_duty(float pct) { return (uint32_t)lroundf(pct * PWM_MAX / 100.0f); }
400dde30: 006136 entry a1, 48
400dde33: 0129 s32i.n a2, a1, 0
400dde35: cb85b1 l32r a11, 400d0c4c <_stext+0xc2c> (42c80000 <_etext+0x2b02a52>)
400dde38: fa0250 wfr f0, a2
400dde3b: cc1181 l32r a8, 400d0e80 <_stext+0xe60> (437f0000 <_etext+0x3672a52>)
400dde3e: fa1850 wfr f1, a8
400dde41: 2a0010 mul.s f0, f0, f1
400dde44: faa040 rfr a10, f0
400dde47: cb7b81 l32r a8, 400d0c34 <_stext+0xc14> (40172c84 <__divsf3>)
400dde4a: 0008e0 callx8 a8
400dde4d: cb6e81 l32r a8, 400d0c08 <_stext+0xbe8> (4016e348 <lroundf>)
400dde50: 0008e0 callx8 a8
400dde53: 0a2d mov.n a2, a10
400dde55: f01d retw.n
Linha a linha:
entry a1, 48: reserva 48 bytes de pilha.pctchegou ema2: no ESP32, até umfloaté passado num registrador inteiro.s32i.n a2, a1, 0: guardapctna pilha. É o-Og(o padrão do ESP-IDF) mantendo a variável visível para o depurador. Não muda o resultado.l32r a11, ... (42c80000): já prepara o segundo argumento de__divsf3ema11. O0x42c80000é o padrão de bits dofloat100,0.wfr f0, a2el32r+wfr f1, a8: levapcte255.0f(0x437f0000) para a FPU.mul.s f0, f0, f1:pct * 255, uma instrução.rfr a10, f0: o produto volta para um registrador inteiro, no lugar do primeiro argumento (a10aqui =a2em__divsf3).callx8 a8coma8 = __divsf3: a divisão por 100 é uma chamada de função.- O resultado volta em
a10, que já é o argumento delroundf(): outra chamada. mov.n a2, a10eretw.n: o retorno delroundfvira o retorno da função.
Para ver o float por trás de um padrão de bits:
py -c "import struct; print(struct.unpack('>f', bytes.fromhex('437f0000'))[0])"
2.3 Sua vez: ler_adc() e enfileirar()
Procure as duas no seu app.lst e anote-as linha a linha, como acima:
static void ler_adc(void)
{
sensores_ler_pot(&adc_raw, &adc_mv);
float sp = SP_MIN + adc_raw * (SP_MAX - SP_MIN) / 4095.0f;
setpoint = roundf(sp * 2) / 2; // passos de 0,5 °C
}
static void enfileirar(tipo_evento_t tipo)
{
evento_t ev = {.tipo = tipo};
if (xQueueSend(fila, &ev, 0) != pdTRUE) ESP_LOGW(TAG, "fila cheia: evento %d perdido", tipo);
}
Em ler_adc, encontre: onde fica adc_raw (o endereço que o l32r carrega), as quatro
constantes float (decodifique cada uma), as duas chamadas de função e o que aconteceu com o
* 2 e com o / 2. Em enfileirar, encontre o memset e explique o 84 que vai em a12, e
descubra em que instrução o xQueueSend do C virou xQueueGenericSend.
P2: (a) pct chega em a2, um registrador inteiro, e precisa de um wfr para entrar na
FPU. Que custo isso tem em cada chamada? (b) Em ler_adc, o / 2 virou mul.s por 0.5
(0x3f000000), mas o / 4095.0f virou __divsf3. Por que o compilador pode trocar o primeiro e
não pode trocar o segundo? (Pense em potências de 2 e em arredondamento.) (c) enfileirar
só preenche .tipo, e mesmo assim zera 84 bytes. Por quê? Essa função roda 10 vezes por segundo:
isso importa?
Evidência: evidencias/t2-anatomia.md com as três funções (atuadores_duty, ler_adc,
enfileirar) copiadas do seu app.lst e anotadas linha a linha, e uma tabela "registrador →
o que guarda" para ler_adc.
- └── 📂evidencias
- └── 📝t2-anatomia.md👈 Criar Aqui
git conferir evidencias/t2-anatomia.md
Anatomia de uma funcao Xtensa
git conferir evidencias/t2-anatomia.md
git add evidencias/t2-anatomia.md && git commit -m "T2: Anatomia de uma funcao Xtensa" && 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 — Onde mora cada coisa
3.1 O mapa do ESP32
O endereço já diz onde um símbolo está. No ESP32 (ESP-IDF, soc.h):
| Faixa | Região | O que fica lá | Seção do ELF |
|---|---|---|---|
0x4000_0000–0x4006_FFFF | ROM (gravada na fábrica) | memset, strcmp, __muldf3, ... | — (só endereço) |
0x4008_0000–0x400A_9FFF | IRAM (RAM de instruções) | interrupções, partes do FreeRTOS, IRAM_ATTR | .iram0.vectors, .iram0.text |
0x400D_0000–0x403F_FFFF | flash, código (via cache) | quase todo o código | .flash.text |
0x3F40_0000–0x3F7F_FFFF | flash, dados (via cache) | const, strings, tabelas | .flash.rodata |
0x3FFA_E000–0x3FFF_FFFF | DRAM (RAM de dados) | variáveis globais, heap, pilhas | .dram0.data, .dram0.bss |
O código na flash não é lido direto: passa por um cache. Se o cache está desligado (durante uma
gravação na flash, por exemplo) e uma interrupção precisa rodar, ela tem que estar na IRAM. É
para isso que serve o IRAM_ATTR.
3.2 Localize
Use o firmware.sym (ou $XT nm -S .pio/build/esp32dev/firmware.elf | grep ...). As funções
da ROM não estão nele (não têm tamanho): procure o nome entre <> no firmware.lst, como
<memset>.
| Símbolo | De onde vem |
|---|---|
app_main, task_app, ler_adc | src/main.c |
esp_timer_get_time, _xt_lowint1 | ESP-IDF (esp_timer, vetores de interrupção) |
memset, strcmp, __muldf3 | chamados pelo seu código (procure no firmware.lst) |
NOME_MODO, estado, setpoint, seq, fila | variáveis do src/main.c |
b64$… | o static char b64[1400] dentro de publicar_framebuffer() |
Para cada um: endereço, região, seção, tamanho e por que ele está lá. Repare nas letras do
nm: T/t código, D/d dado com valor inicial, B/b dado zerado (.bss), maiúscula =
global, minúscula = static.
3.3 Experimento: IRAM_ATTR
Em src/atuadores.c, inclua #include "esp_attr.h" e marque a função:
uint32_t IRAM_ATTR atuadores_duty(float pct) { return (uint32_t)lroundf(pct * PWM_MAX / 100.0f); }
Recompile e compare com o build anterior: o endereço novo de atuadores_duty, a linha de IRAM do
esp_idf_size (antes e depois) e o endereço das duas funções que ela chama. Depois desfaça
a mudança.
4008312c <atuadores_duty>:
4008312c: 006136 entry a1, 48
...
40083143: f5b081 l32r a8, 40080804 <_iram_text_start+0x400> (40172c58 <__divsf3>)
40083146: 0008e0 callx8 a8
40083149: f5af81 l32r a8, 40080808 <_iram_text_start+0x404> (4016e31c <lroundf>)
P3: (a) Antes de procurar, diga em que região você espera cada símbolo da tabela 3.2.
Errou algum? (b) NOME_MODO é static const char *NOME_MODO[]: os ponteiros do array não são
const, e mesmo assim ele está em 0x3F4…. Já estado (static const char *estado) está na
DRAM. O que o compilador percebeu num e não no outro? (c) Com IRAM_ATTR, atuadores_duty pode
rodar com o cache desligado? Olhe para onde apontam os dois callx8. (d) .dram0.data ocupa
espaço no firmware.bin e .dram0.bss, não. Por quê?
Evidência: evidencias/t3-memoria.md com a tabela da 3.2 preenchida (endereço, região,
seção, tamanho, por quê) e o experimento da 3.3 (endereços e IRAM antes e depois).
- └── 📂evidencias
- └── 📝t3-memoria.md👈 Criar Aqui
git conferir evidencias/t3-memoria.md
Onde mora cada coisa
git conferir evidencias/t3-memoria.md
git add evidencias/t3-memoria.md && git commit -m "T3: Onde mora cada coisa" && 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 — Bancada de ciclos
4.1 O contador de ciclos
Todo núcleo Xtensa tem um registrador CCOUNT, que soma 1 a cada ciclo de relógio da CPU
(160 MHz no ESP-IDF; o core Arduino usa 240 MHz). esp_cpu_get_cycle_count() o lê com uma
instrução. Ler antes e depois de um trecho dá o custo dele em ciclos.
Medir uma instrução isolada é difícil: a medida tem um custo próprio, e uma interrupção no meio
estraga a amostra. A bancada abaixo resolve as duas coisas: chama cada operação 64 vezes, repete
8 vezes, fica com a menor rodada e desconta o custo de uma chamada "vazia" (op_base).
// bancada.h — Lab 11 (T4): mede o custo (ciclos de CPU) de operações básicas.
#pragma once
#include <stddef.h>
// Roda todas as medidas (~50 ms), escreve a tabela no log e o resultado em JSON.
// Devolve o tamanho do JSON, ou 0 se não coube.
size_t bancada_rodar(char *json, size_t capacidade);
// bancada.c — Lab 11 (T4): quanto custa cada operação no ESP32, em ciclos de CPU.
//
// O contador CCOUNT do Xtensa soma 1 a cada ciclo do relógio da CPU (160 MHz no ESP-IDF).
// Cada medida chama a operação N vezes, repete REPETICOES vezes e fica com a MENOR: assim uma
// interrupção no meio de uma rodada não estraga o resultado. Do total sai o custo da chamada
// "vazia" (op_base), que só lê os operandos e grava o resultado.
//
// Os operandos são volatile: sem isso, o compilador calcularia 123457 * 321 na compilação e a
// "medida" seria de uma constante. Cada operação fica numa função noinline, para aparecer
// separada no firmware.lst (T4: compare os ciclos com as instruções de cada uma).
#include "bancada.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "esp_attr.h"
#include "esp_cpu.h"
#include "esp_log.h"
static const char *TAG = "bancada";
#define N 64 // chamadas por rodada
#define REPETICOES 8 // rodadas (fica a menor)
#define NOINLINE __attribute__((noinline))
static volatile int32_t ia = 123457, ib = 321;
static volatile float fa = 37.5f, fb = 4095.0f;
static volatile double da = 37.5, db = 4095.0;
static volatile int32_t ri;
static volatile float rf;
static volatile double rd;
static char texto[32];
// ------------------------------------------------------------------ as operações
static NOINLINE void op_base(void) { ri = ia; } // referência: lê e grava
static NOINLINE void op_int_soma(void) { ri = ia + ib; }
static NOINLINE void op_int_mul(void) { ri = ia * ib; }
static NOINLINE void op_int_div(void) { ri = ia / ib; }
static NOINLINE void op_int_div16(void) { ri = ia / 16; } // divisor constante
static NOINLINE void op_float_soma(void) { rf = fa + fb; }
static NOINLINE void op_float_mul(void) { rf = fa * fb; }
static NOINLINE void op_float_div(void) { rf = fa / fb; }
static NOINLINE void op_float_inv(void) { rf = fa * (1.0f / 4095.0f); } // multiplica pelo inverso
static NOINLINE void op_float_sqrt(void) { rf = sqrtf(fa); }
static NOINLINE void op_double_mul(void) { rd = da * db; }
static NOINLINE void op_double_div(void) { rd = da / db; }
static NOINLINE void op_int_para_float(void) { rf = (float)ia; }
static NOINLINE void op_snprintf_int(void) { snprintf(texto, sizeof(texto), "%ld", (long)ia); }
static NOINLINE void op_snprintf_float(void) { snprintf(texto, sizeof(texto), "%.1f", fa); }
// mesma função, duas casas: uma na flash (via cache), outra na IRAM
static NOINLINE void op_flash(void) { ri = ia * ib + ia; }
static NOINLINE IRAM_ATTR void op_iram(void) { ri = ia * ib + ia; }
typedef struct {
const char *nome;
void (*f)(void);
} operacao_t;
static const operacao_t OPS[] = {
{"int_soma", op_int_soma},
{"int_mul", op_int_mul},
{"int_div", op_int_div},
{"int_div16", op_int_div16},
{"float_soma", op_float_soma},
{"float_mul", op_float_mul},
{"float_div", op_float_div},
{"float_inv", op_float_inv},
{"float_sqrt", op_float_sqrt},
{"double_mul", op_double_mul},
{"double_div", op_double_div},
{"int_para_float", op_int_para_float},
{"snprintf_int", op_snprintf_int},
{"snprintf_float", op_snprintf_float},
{"flash", op_flash},
{"iram", op_iram},
};
#define N_OPS (sizeof(OPS) / sizeof(OPS[0]))
// ------------------------------------------------------------------ medida
static uint32_t medir(void (*f)(void))
{
uint32_t menor = UINT32_MAX;
for (int r = 0; r < REPETICOES; r++) {
uint32_t t0 = esp_cpu_get_cycle_count();
for (int i = 0; i < N; i++) f();
uint32_t dt = esp_cpu_get_cycle_count() - t0; // unsigned: certo mesmo se der a volta
if (dt < menor) menor = dt;
}
return menor;
}
// c10 = ciclos x 10 -> "12.5" (inteiros: sem usar o float que estamos medindo)
static void formatar(char *s, size_t cap, int32_t c10)
{
snprintf(s, cap, "%s%ld.%ld", c10 < 0 ? "-" : "", labs(c10) / 10, labs(c10) % 10);
}
size_t bancada_rodar(char *json, size_t capacidade)
{
uint32_t base = medir(op_base);
size_t n = snprintf(json, capacidade, "{\"n\":%d,\"base\":%lu", N, (unsigned long)(base / N));
ESP_LOGI(TAG, "%-15s %8s", "operacao", "ciclos");
for (size_t i = 0; i < N_OPS; i++) {
uint32_t total = medir(OPS[i].f);
int32_t c10 = ((int32_t)total - (int32_t)base) * 10 / N; // por chamada, sem a base
char c[12];
formatar(c, sizeof(c), c10);
ESP_LOGI(TAG, "%-15s %8s", OPS[i].nome, c);
if (n < capacidade) n += snprintf(json + n, capacidade - n, ",\"%s\":%s", OPS[i].nome, c);
}
if (n < capacidade) n += snprintf(json + n, capacidade - n, "}");
return n < capacidade ? n : 0;
}
4.2 Ligando ao firmware
No config.h, os tópicos novos (o TOPICO_CMD_FALHA já fica pronto para a T6):
#define TOPICO_BANCADA BASE "/bancada" // Lab 11 (T4): resultado da bancada
#define TOPICO_CMD_BANCADA BASE "/cmd/bancada" // Lab 11 (T4): qualquer texto roda a bancada
#define TOPICO_CMD_FALHA BASE "/cmd/falha" // Lab 11 (T6): nulo | div0 | travar
No rede.c, assine os dois comandos no MQTT_EVENT_CONNECTED, junto dos outros:
esp_mqtt_client_subscribe(mqtt, TOPICO_CMD_BANCADA, 0); // Lab 11
esp_mqtt_client_subscribe(mqtt, TOPICO_CMD_FALHA, 0); // Lab 11
No main.c, #include "bancada.h" e um ramo novo em tratar_comando(), antes do de
aquecedor/ventilador. A bancada roda na task app (CPU 1), como qualquer comando:
} else if (strcmp(topico, TOPICO_CMD_BANCADA) == 0) { // Lab 11 (T4)
static char json[512]; // static: fora da pilha da app
if (bancada_rodar(json, sizeof(json)) > 0) rede_publicar(TOPICO_BANCADA, json, -1);
E o bancada.c entra no componente:
idf_component_register(
SRCS "main.c" "rede.c" "sensores.c" "atuadores.c" "tela.c" "bancada.c"
INCLUDE_DIRS "."
PRIV_REQUIRES esp_wifi esp_netif esp_event nvs_flash esp_timer esp_adc
esp_driver_ledc esp_driver_i2c esp_driver_gpio esp_lcd mbedtls
mqtt dht22 gfx)
4.3 Medindo
- 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/lab11/grupo-a/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-a/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-b/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-b/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-c/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-c/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-d/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-d/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-e/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-e/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-f/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-f/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-g/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-g/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-h/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-h/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-i/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-i/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-j/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-j/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-k/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-k/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-l/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-l/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-m/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-m/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-x/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-x/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-p/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-p/cmd/bancada" -m 1
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab11/grupo-n/bancada" -v
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-n/cmd/bancada" -m 1
Saída esperada (valores ilustrativos, medidos no QEMU da Espressif):
I (2020) app: [CMD] elt73a/lab11/grupo-a/cmd/bancada <- '1'
I (2020) bancada: operacao ciclos
I (2020) bancada: int_soma 5.1
I (2020) bancada: int_mul 5.1
I (2020) bancada: int_div 5.1
I (2020) bancada: int_div16 3.8
I (2020) bancada: float_soma 5.1
I (2020) bancada: float_mul 5.1
I (2020) bancada: float_div 43.5
I (2020) bancada: float_inv 3.8
I (2021) bancada: float_sqrt 51.2
I (2021) bancada: double_mul 84.4
I (2023) bancada: double_div 513.2
I (2023) bancada: int_para_float 1.2
I (2028) bancada: snprintf_int 1317.6
I (2045) bancada: snprintf_float 5347.6
I (2045) bancada: flash 8.9
I (2045) bancada: iram 8.9
O Wokwi e o QEMU executam as instruções, mas não reproduzem o tempo de cada uma: o CCOUNT
deles anda mais ou menos por instrução executada. Num ESP32 de verdade, quos leva vários
ciclos, a FPU tem latência e um acesso à flash fora do cache custa dezenas de ciclos. Os seus
números vão ser outros. O que vale aqui é a ordem de grandeza, e ela você explica contando
instruções no app.lst. É o mesmo motivo de o cenário do Lab 10 medir o PWM no VCD, com
tolerância, em vez de confiar no tempo exato de cada instrução.
4.4 Explicando cada número
Para cada operação, abra a função op_... no app.lst e conte as instruções a mais que a
op_base. Duas delas, para comparar:
400de050 <op_int_soma>:
400de053: cb9b81 l32r a8, 400d0ec0 <_stext+0xea0> (3ffb05ac <ia>)
400de056: 0020c0 memw
400de059: 0888 l32i.n a8, a8, 0
400de05b: cb9b91 l32r a9, 400d0ec8 <_stext+0xea8> (3ffb05a8 <ib>)
400de05e: 0020c0 memw
400de061: 0998 l32i.n a9, a9, 0
400de063: 889a add.n a8, a8, a9
...
400de118 <op_float_div>:
...
400de129: 08b8 l32i.n a11, a8, 0
400de12b: cac281 l32r a8, 400d0c34 <_stext+0xc14> (40172c84 <__divsf3>)
400de12e: 0008e0 callx8 a8
Quando a operação vira uma chamada, siga o endereço até a função chamada no firmware.lst (por
exemplo, procure <__divsf3>:) e conte o que tem lá dentro. Se o endereço for de ROM
(0x4000…–0x4006…), o código não está no seu ELF: ele está gravado no chip.
P4: (a) Antes de rodar, ordene as 16 operações da mais barata para a mais cara. Onde você
errou? (b) No simulador, int_div custa o mesmo que int_soma. Por quê? Num chip real seria
igual? (c) float_div custa ~8 vezes float_mul. Abra o __divsf3 no firmware.lst: que
instruções da FPU ele usa no lugar de uma divisão? (d) Em que região está o __muldf3? O que isso
diz sobre double no ESP32? (e) Cada snprintf("%.1f") custa milhares de ciclos, e o .../pwm
e o .../dht formatam vários float a cada mensagem. A 160 MHz, quanto tempo isso dá por
mensagem? É um problema a cada 5 s? E a 1 kHz? (f) Por que flash e iram deram o mesmo número?
Em que situação, num chip real, eles seriam diferentes?
Evidências: em evidencias/t4-bancada.txt, a tabela do serial e o JSON do .../bancada; em
evidencias/t4-analise.md, uma tabela com uma linha por operação: ciclos medidos, instruções a
mais que a op_base (ou "chama __divsf3", etc.) e uma frase de explicação.
- ├── 📂src
- ├── 📄bancada.h👈 Criar Aqui
- ├── 📄bancada.c👈 Criar Aqui
- ├── 📄config.h👈 Edite Aqui
- ├── 📄rede.c👈 Edite Aqui
- ├── 📄main.c👈 Edite Aqui
- └── 📄CMakeLists.txt👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t4-bancada.txt👈 Criar Aqui
- └── 📝t4-analise.md👈 Criar Aqui
git conferir src/bancada.h src/bancada.c src/config.h src/rede.c src/main.c src/CMakeLists.txt evidencias/t4-bancada.txt evidencias/t4-analise.md
Bancada de ciclos
git conferir src/bancada.h src/bancada.c src/config.h src/rede.c src/main.c src/CMakeLists.txt evidencias/t4-bancada.txt evidencias/t4-analise.md
git add src/bancada.h src/bancada.c src/config.h src/rede.c src/main.c src/CMakeLists.txt evidencias/t4-bancada.txt evidencias/t4-analise.md && git commit -m "T4: Bancada de ciclos" && 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 — Níveis de otimização e volatile
5.1 Quatro funções, quatro níveis
O ESP-IDF compila com -Og por padrão ("Debug": otimiza sem atrapalhar o depurador). O
Arduino usa -Os. Para ver o que cada nível faz, sem esperar um build inteiro, compile um arquivo
fora do firmware:
// exemplos/otimizacao.c — Lab 11 (T5): o que o compilador faz com o seu C.
// Compile com níveis diferentes e compare o assembly (veja o enunciado):
// xtensa-esp32-elf-gcc -mlongcalls -O0 -S -o - exemplos/otimizacao.c
#include <stdbool.h>
#include <stdint.h>
// 1. média de 16 amostras (sensores_ler_pot do Lab 09): divisão por constante
int media16(const int *v)
{
int soma = 0;
for (int i = 0; i < 16; i++) soma += v[i];
return soma / 16; // int: e se fosse unsigned?
}
unsigned media16_u(const unsigned *v)
{
unsigned soma = 0;
for (int i = 0; i < 16; i++) soma += v[i];
return soma / 16;
}
// 2. ADC -> setpoint (ler_adc do Lab 09): dividir ou multiplicar pelo inverso?
float sp_divide(int raw) { return 20.0f + raw * 35.0f / 4095.0f; }
float sp_multiplica(int raw) { return 20.0f + raw * (35.0f / 4095.0f); }
// 3. espera "ocupada" por uma flag que OUTRA task muda (wifi_ok, no rede.c do Lab 09)
bool pronto; // sem volatile
volatile bool pronto_v; // com volatile
void esperar(void) { while (!pronto) { } }
void esperar_v(void) { while (!pronto_v) { } }
// 4. um "delay" feito com laço
void atraso(void)
{
for (int i = 0; i < 100000; i++) { }
}
void atraso_v(void)
{
for (volatile int i = 0; i < 100000; i++) { }
}
pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-gcc -mlongcalls -O0 -S -o exemplos/otimizacao-O0.s exemplos/otimizacao.c
pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-gcc -mlongcalls -O0 -c -o exemplos/otimizacao-O0.o exemplos/otimizacao.c
pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-nm -S --size-sort exemplos/otimizacao-O0.o
O .s mostra o código; o nm -S do .o, o tamanho de cada função em bytes. Um exemplo do que
você vai encontrar:
# -Og # -Os
esperar: esperar:
entry sp, 32 entry sp, 32
.L10: l32r a8, .LC8 # &pronto
l32r a8, .LC5 # &pronto l8ui a8, a8, 0 # lê UMA vez
l8ui a8, a8, 0 # lê a cada volta bnez.n a8, .L11
beqz.n a8, .L10 .L13:
retw.n j .L13 # laço infinito
.L11:
retw.n
Em -Os, o compilador lê pronto uma vez: se for falso, entra num j para ele mesmo e nunca
mais olha. Para o C isso está correto, porque nada dentro do laço muda pronto, e o
compilador não sabe que outra task muda. Em -Og o defeito fica escondido: o código funciona
no build de depuração e trava no de produção.
5.2 O firmware inteiro em três níveis
O nível do firmware vem do sdkconfig. Acrescente uma linha ao sdkconfig.defaults,
apague o sdkconfig.esp32dev (senão ele não é regenerado) e compile. Atenção: muda o nível
de todo o ESP-IDF, então o build é completo (alguns minutos).
# -Os: tamanho
CONFIG_COMPILER_OPTIMIZATION_SIZE=y
# -O2: desempenho
CONFIG_COMPILER_OPTIMIZATION_PERF=y
Anote, para -Og (o build que você já tem), -Os e -O2: o tamanho do app, a IRAM e a "Flash
Code" do esp_idf_size, a linha da biblioteca do src/ no --archives e o tamanho de
task_app e de tratar_comando no firmware.sym. Rode a bancada da T4 em -O2 também.
app 964 960 bytes · IRAM 90 063 · Flash Code 710 030 · task_app 0x123 · tratar_comando 0x212
No fim, volte ao padrão: tire a linha do sdkconfig.defaults, apague o sdkconfig.esp32dev e
compile de novo. A T6 precisa do -Og.
P5 (parte 1): (a) Na 5.1, em que níveis atraso() sumiu? Se você precisa de um atraso
curto de verdade, o que usar no ESP-IDF? (b) Por que media16 (com int) precisa de três
instruções para dividir por 16 e media16_u (com unsigned), de uma? O que é a instrução loop
que aparece em -Os? (c) No rede.c do Lab 09, wifi_ok é volatile. Abra rede_wifi_ok no
app.lst e mostre o memw. O que poderia acontecer sem o volatile, e em que nível? (d) Na 5.2,
qual nível deu o menor app? Em -Os e -O2, tratar_comando some do firmware.sym e a
task_app cresce. O que aconteceu, e o que isso muda num backtrace? (e) No Lab 10, o pio test -e native compila com o gcc do PC (outro compilador, outras opções), e o firmware vai para o ESP32
com o nível do framework. Um esperar() sem volatile seria pego pelos testes do PC? Em que nível o pipeline precisa compilar o
firmware que ele testa no Wokwi, e por quê?
Evidência: evidencias/t5-otimizacao.md com: uma tabela "função × nível" (bytes do nm -S
e o que mudou) para as oito funções de exemplos/otimizacao.c; o esperar e o esperar_v em
-Os comentados; e a tabela da 5.2 com os três níveis.
- ├── 📂exemplos
- └── 📄otimizacao.c👈 Criar Aqui
- └── 📂evidencias
- └── 📝t5-otimizacao.md👈 Criar Aqui
git conferir exemplos/otimizacao.c evidencias/t5-otimizacao.md
Niveis de otimizacao e volatile
git conferir exemplos/otimizacao.c evidencias/t5-otimizacao.md
git add exemplos/otimizacao.c evidencias/t5-otimizacao.md && git commit -m "T5: Niveis de otimizacao e volatile" && 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 — diagnóstico de falhas pelo assembly
Quando o firmware acessa um endereço proibido ou divide por zero, o processador gera uma exceção. O ESP-IDF a captura, imprime um Guru Meditation com os registradores e reinicia. Não há nome de função, nem linha: só endereços. Nesta tarefa você provoca três falhas de propósito e chega à linha do C a partir deles.
Código
// falhas.h — Lab 11 (T6): defeitos propositais para analisar o crash pelo assembly.
#pragma once
#include <stdbool.h>
// tipo: "nulo", "div0" ou "travar". Devolve false se o tipo não existe
// (nos outros casos, normalmente não volta).
bool falhas_provocar(const char *tipo);
// falhas.c — Lab 11 (T6): três defeitos de propósito, para diagnosticar pelo assembly.
//
// cmd/falha nulo -> grava por um ponteiro NULL (StoreProhibited)
// cmd/falha div0 -> divide um inteiro por zero (IntegerDivideByZero)
// cmd/falha travar -> laço sem fim na task app: o IDLE1 não roda (task watchdog)
//
// Os dois primeiros derrubam o ESP32 (Guru Meditation + reboot). O terceiro não: o watchdog só
// avisa a cada 5 s e mostra onde a CPU 1 está presa. Nos três, a saída do serial traz endereços
// (PC, EXCVADDR, Backtrace) que você vai achar no firmware.lst.
#include "falhas.h"
#include <string.h>
#include "esp_log.h"
static const char *TAG = "falhas";
#define NOINLINE __attribute__((noinline))
typedef struct {
int raw;
int mv;
float setpoint;
} leitura_t;
static leitura_t *ultima_leitura; // nunca inicializado: continua NULL
static volatile int divisor; // volatile: o compilador não sabe que é 0
static volatile uint32_t voltas;
static NOINLINE void guardar_setpoint(leitura_t *l, float sp)
{
l->setpoint = sp; // l == NULL -> grava no endereço 0 + 8
}
static NOINLINE int media(int soma, int n)
{
return soma / n; // n == 0 -> exceção do hardware (instrução quos)
}
static NOINLINE void esperar_para_sempre(void)
{
for (;;) voltas++; // nunca cede a CPU: o IDLE1 não roda
}
bool falhas_provocar(const char *tipo)
{
if (strcmp(tipo, "nulo") == 0) {
ESP_LOGW(TAG, "gravando por um ponteiro NULL...");
guardar_setpoint(ultima_leitura, 37.5f);
} else if (strcmp(tipo, "div0") == 0) {
ESP_LOGW(TAG, "dividindo por zero...");
ESP_LOGI(TAG, "media = %d", media(1234, divisor));
} else if (strcmp(tipo, "travar") == 0) {
ESP_LOGW(TAG, "travando a task app (o watchdog avisa a cada 5 s)...");
esperar_para_sempre();
} else {
return false;
}
return true;
}
No main.c, #include "falhas.h" e mais um ramo em tratar_comando(); no
src/CMakeLists.txt, acrescente "falhas.c" ao SRCS:
} else if (strcmp(topico, TOPICO_CMD_FALHA) == 0) { // Lab 11 (T6)
if (!falhas_provocar(txt)) ESP_LOGW(TAG, "[CMD] falha desconhecida (use nulo, div0 ou travar)");
- 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/lab11/grupo-a/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-b/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-c/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-d/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-e/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-f/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-g/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-h/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-i/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-j/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-k/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-l/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-m/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-x/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-p/cmd/falha" -m nulo
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab11/grupo-n/cmd/falha" -m nulo
Lendo um Guru Meditation
Saída esperada de cmd/falha nulo (os endereços do seu firmware são outros):
I (2220) app: [CMD] elt73a/lab11/grupo-a/cmd/falha <- 'nulo'
W (2220) falhas: gravando por um ponteiro NULL...
Guru Meditation Error: Core 1 panic'ed (StoreProhibited). Exception was unhandled.
Core 1 register dump:
PC : 0x400e717b PS : 0x00060230 A0 : 0x800dc090 A1 : 0x3ffbb8b0
A2 : 0x00000000 A3 : 0x42160000 A4 : 0x3f40468c A5 : 0x000008ac
...
A14 : 0x00000037 A15 : 0x00000000 SAR : 0x00000004 EXCCAUSE: 0x0000001d
EXCVADDR: 0x00000008 LBEG : 0x400012e5 LEND : 0x40001309 LCOUNT : 0x800dc072
Backtrace: 0x400e7178:0x3ffbb8b0 0x400dc08d:0x3ffbb8d0 0x400db3d5:0x3ffbb8f0 0x400db766:0x3ffbb940 0x400eac5d:0x3ffbb9d0
ELF file SHA256: 5384cd995
Rebooting...
| Campo | O que é |
|---|---|
Core 1 panic'ed (StoreProhibited) | o núcleo e o tipo da exceção |
PC | o endereço da instrução que falhou |
EXCCAUSE | o código da causa: 6 IntegerDivideByZero, 28 (0x1c) LoadProhibited, 29 (0x1d) StoreProhibited, 0 IllegalInstruction |
EXCVADDR | o endereço de memória que a instrução tentou acessar |
A0…A15 | os registradores da janela da função que falhou: os argumentos dela estão em A2, A3... |
A0 | o endereço de retorno. Os 2 bits de cima guardam o tamanho da janela: 0x800dc090 → troque o 8 por 4 → 0x400dc090 |
Backtrace | pares PC:SP de cada função na pilha, da que falhou até a primeira |
Para transformar os endereços em funções e linhas:
pio pkg exec -p toolchain-xtensa-esp-elf -- xtensa-esp32-elf-addr2line -pfiaC -e .pio/build/esp32dev/firmware.elf 0x400e717b 0x400dc08d 0x400db3d5 0x400db766 0x400eac5d
0x400e717b: guardar_setpoint at src/falhas.c:32
0x400dc08d: falhas_provocar at src/falhas.c:49
0x400db3d5: tratar_comando at src/main.c:319
0x400db766: task_app at src/main.c:383
0x400eac5d: vPortTaskWrapper at .../freertos/FreeRTOS-Kernel/portable/xtensa/port.c:147
Agora procure o PC no app.lst:
400e7178 <guardar_setpoint>:
400e7178: 004136 entry a1, 32
l->setpoint = sp; // l == NULL -> grava no endereço 0 + 8
400e717b: 2239 s32i.n a3, a2, 8
s32i.n a3, a2, 8 grava a3 no endereço a2 + 8. O dump diz A2 = 0 (o ponteiro l), A3 = 0x42160000 (o float 37,5) e EXCVADDR = 0x8, que é 0 + 8: o deslocamento do campo
setpoint dentro de leitura_t.
Requisitos
- Os três casos. Para
nulo,div0etravar: copie a saída do serial, decodifique o backtrace com oaddr2line, ache oPC(notravar, o terceiro endereço do backtrace) no seuapp.lste explique com os registradores qual valor causou a falha. div0. Qual instrução falhou? Em que registradores estavam o dividendo e o divisor? Por que odivisorprecisa servolatilepara a falha acontecer?travar. O ESP32 não reinicia. Explique, pela mensagem dotask_wdt, quem o watchdog está vigiando e por que ele aparece a cada 5 s. Explique também a enxurrada defila cheia: evento 1 perdido(qual evento é o 1, e em quanto tempo a fila enche). O.../statuscontinuaonline? Por quê? Para sair, reinicie a simulação.- O bug que sumiu. Compile com
CONFIG_COMPILER_OPTIMIZATION_SIZE=y(como na 5.2), mandecmd/falha nulode novo e veja o que acontece. Procurefalhas_provocarnoapp.lste explique. Depois volte ao-Og. - Evidência:
evidencias/t6-falhas.mdcom os itens 1 a 4.
Saída esperada do travar (trecho):
W (2220) falhas: travando a task app (o watchdog avisa a cada 5 s)...
W (3820) app: fila cheia: evento 1 perdido
W (3920) app: fila cheia: evento 1 perdido
...
E (7219) task_wdt: Task watchdog got triggered. The following tasks/users did not reset the watchdog in time:
E (7219) task_wdt: - IDLE1 (CPU 1)
E (7219) task_wdt: Tasks currently running:
E (7219) task_wdt: CPU 0: IDLE0
E (7219) task_wdt: CPU 1: app
E (7219) task_wdt: Print CPU 1 backtrace
Backtrace: 0x40083D82:0x3FFB1EC0 0x40083159:0x3FFB1EE0 0x400DC056:0x3FFBB8B0 0x400DC107:0x3FFBB8D0 0x400DB3D5:0x3FFBB8F0 0x400DB766:0x3FFBB940 0x400EAC5D:0x3FFBB9D0
P5 (parte 2): (a) Antes de mandar o nulo, diga qual vai ser o EXCVADDR. E se o campo fosse
raw em vez de setpoint? (b) Os dois primeiros endereços do backtrace do travar são
esp_crosscore_isr e _xt_lowint1, que não são seus. De onde eles vêm? (c) No item 4, o compilador
apagou a gravação. Ele errou? O que o padrão C diz sobre gravar por um ponteiro nulo, e por que
isso é pior do que o crash?
Dicas
- O
PCdo registrador é a instrução que falhou. NoBacktrace, os endereços das funções de cima são endereços de retorno (a instrução depois docall). Por isso eles caem uma linha depois da chamada. addr2lineaceita vários endereços de uma vez. Basta colar a parte antes de cada:.- Para decodificar automaticamente, o Wokwi pode expor a serial por RFC2217: acrescente
rfc2217ServerPort = 4000ao[wokwi]dowokwi.tomle rodepio device monitor -p rfc2217://localhost:4000. O filtroesp32_exception_decoderdoplatformio.initraduz o backtrace sozinho. Faça a decodificação manual antes: é ela que vale a nota. - No pipeline do Lab 10, um crash vira CI vermelho com uma linha: acrescente
--fail-text "Guru Meditation"à chamada dowokwi-cli. Ele encerra com erro assim que o texto aparece no serial, mesmo que o teste "esperado" ainda não tenha falhado.
- ├── 📂src
- ├── 📄falhas.h👈 Criar Aqui
- ├── 📄falhas.c👈 Criar Aqui
- ├── 📄main.c👈 Edite Aqui
- └── 📄CMakeLists.txt👈 Edite Aqui
- ├── 📂evidencias
- └── 📝t6-falhas.md👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir src/falhas.h src/falhas.c src/main.c src/CMakeLists.txt evidencias/t6-falhas.md README.md
Diagnostico de falhas pelo assembly
git conferir src/falhas.h src/falhas.c src/main.c src/CMakeLists.txt evidencias/t6-falhas.md README.md
git add src/falhas.h src/falhas.c src/main.c src/CMakeLists.txt evidencias/t6-falhas.md README.md && git commit -m "T6: Diagnostico de falhas pelo assembly" && 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.