Pular para o conteúdo principal

Laboratório 06

Checklist — SSD1306, MQTT nos dois sentidos e dashboard​

  • Stack Docker do curso rodando (T1, sem pontos)
  • platformio.ini com Adafruit SSD1306 + GFX; diagram.json com o OLED em SDA 21 / SCL 22 (T2)
  • Tela local desenhada só quando muda (telaSuja), fora do callback do temporizador (T3)
  • Intervalo alterado por MQTT (.../cmd/intervalo, 2–60 s) e tela espelhada em texto em .../oled (T4)
  • Dashboard mínimo no Node-RED: réplica do OLED em texto, status e slider do intervalo (T5)
  • Framebuffer do SSD1306 em .../oled/fb desenhado pixel a pixel no dashboard (T6)
  • Previsões P1–P3 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 0 · T2 10 · T3 20 · T4 25 · T5 20 · T6 25. 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

Esta aula continua o Lab 05: o mesmo nó de telemetria (DHT22 + Ticker + MQTT + LWT) ganha um display OLED SSD1306. O MQTT passa a funcionar nos dois sentidos: o ESP32 publica as leituras e o conteúdo da tela, e o Node-RED manda comandos de volta, como o intervalo de leitura. No Node-RED, um dashboard mínimo mostra a tela do OLED de duas formas: como texto e pixel a pixel, a partir do framebuffer. Gravar as leituras num banco (SQLite) fica para o Lab 08.

Objetivos​

  • Ligar um display SSD1306 (I2C) ao ESP32 e entender o framebuffer: o desenho acontece na RAM, e só display() envia os 1024 bytes pelo barramento.
  • Atualizar a tela só quando algo muda (flag telaSuja), sem bloquear o loop().
  • Usar MQTT nos dois sentidos: assinar um tópico de comando e mudar o intervalo do temporizador remotamente.
  • Visualizar o SSD1306 no dashboard do Node-RED: réplica em texto (T5) e réplica fiel, pixel a pixel, a partir do framebuffer (T6), com o mínimo de nós.

Material​

  • VS Code + PlatformIO + extensão Wokwi (ESP32 simulado, sem placa física).
  • Stack Docker do curso: nesta aula usamos o Node-RED com o Dashboard 2.0 (@flowfuse/node-red-dashboard), já instalado na imagem.
  • Bibliotecas novas (baixadas pelo PlatformIO): adafruit/Adafruit SSD1306 e adafruit/Adafruit GFX Library. As do Lab 05 continuam.
Por que Wokwi (e não placa física)?

O Wokwi simula o SSD1306 por I2C além do DHT22 e do Wi-Fi, então a aula roda inteira nele. Numa placa física o firmware é o mesmo. Confira só o endereço I2C do seu módulo: a maioria é 0x3C, alguns são 0x3D.

Clonar o repositório do grupo​

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/lab06-grupo-a.git && cd lab06-grupo-a

3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:

cd /d "%USERPROFILE%\ELT73AS22\lab06-grupo-a" && code . --profile "ESP32IO"

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

  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.

Suba os containers​

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: ELT73A - Sistemas Microcontrolados.

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

set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab06-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-a"

2. Gere o LAB IoT do grupo em docker\lab06-a:

py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"

3. Suba os containers (a primeira vez demora):

cd /d "%IOT_DIR%" && docker compose up -d --build

4. Abra o Portal: http://localhost/

start http://localhost/

5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):

(cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && (del /q "data\lab06-a\flows.json" "data\lab06-a\flows_cred.json" "data\lab06-a\.flows*.backup" 2>nul & docker compose start lab06-a-nodered))
Precisa de mais?

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


Mapa de tarefas — 6 tarefas · 100 pts

O repositório do grupo nasce do lab06-template, que já traz o firmware final do Lab 05 (com LWT) em src/main.cpp:

Estrutura de Arquivos do Projeto
📂 lab06-grupo-x/
  • ├── 🔧platformio.ini👈 Edite Aqui
  • ├── 📂src
    • └── 📄main.cpp👈 Edite Aqui
  • ├── 🔧diagram.json👈 Edite Aqui
  • ├── 🔧wokwi.toml👈 Verificar
  • ├── 📄.gitignore👈 Verificar
  • ├── 📂.vscode
    • └── 🔧extensions.json👈 Verificar
  • ├── 📂nodered
    • └── 🔧flows-lab06.json👈 Criar Aqui
  • ├── 📂evidencias
    • ├── 📄t3-serial.txt👈 Criar Aqui
    • ├── 📄t3-oled.png👈 Criar Aqui
    • ├── 📄t4-mqtt.txt👈 Criar Aqui
    • ├── 📄t5-dashboard.png👈 Criar Aqui
    • ├── 📄t6-fb.txt👈 Criar Aqui
    • └── 📄t6-oled.png👈 Criar Aqui
  • └── 📝README.md👈 Edite Aqui
Tópicos do Lab 06

Tudo fica sob elt73a/lab06/grupo-x/. Troque o X (e o #define GRUPO) pela letra do seu grupo.

TópicoSentidoPayload
.../dhtESP32 → broker{"grupo":"a","seq":7,"t":24.5,"h":55.0,"uptime_ms":35210,"intervalo_s":5.0}
.../statusESP32 → brokeronline / offline (retido, LWT)
.../oledESP32 → broker{"linhas":["LAB06 grupo a","T: 24.5 C", ...]} (T4)
.../oled/fbESP32 → broker1024 bytes do framebuffer em base64 (T6)
.../cmd/intervalobroker → ESP3210 (segundos, 2–60)

Parte 0 — Docker Operacional​

Antes de começar

Precisa do Docker Desktop aberto (com pelo menos 4 GB de memória) e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.

docker desktop start

Disciplina: ELT73A - Sistemas Microcontrolados (--disciplina elt73a).

Configuração do lab06: --sem-gitea--sem-microbin--sem-fuxa--sem-ntfy--captura--docs

  • Conta: lab06-a (usuário, tópicos MQTT lab06-a/#)
  • Gerador (%IOT_GEN%): %USERPROFILE%\ELT73AS22\lab06-grupo-a\docker\gen_iot_aluno.py
  • Pasta do LAB IoT (%IOT_DIR%): %USERPROFILE%\ELT73AS22\lab06-grupo-a\docker\lab06-a

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

set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab06-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-a"

2. Gere o LAB IoT do grupo em docker\lab06-a:

py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"

3. Suba os containers (a primeira vez demora):

cd /d "%IOT_DIR%" && docker compose up -d --build

4. Listar e exibir o status dos containers:

docker compose ps

5. Veja suas credenciais:

cd /d "%IOT_DIR%" && chcp 65001 >nul && type credenciais.txt

6. Abra o portal:

start http://localhost/

7. Ao terminar, pare os containers de todos os projetos Docker Compose em execução (funciona em qualquer janela do cmd, sem os atalhos; os dados ficam; para voltar, use o passo 3 ou Subir de novo):

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

Em um arquivo .cmd/.bat, troque %i por %%i. Para parar só este LAB IoT:

cd /d "%IOT_DIR%" && docker compose down

Se quiser, feche também o Docker Desktop para liberar a memória:

docker desktop stop
Endereços
Operações com Docker

Subir de novo (depois de reiniciar o PC ou de um down):

cd /d "%IOT_DIR%" && docker compose up -d

Parar (os dados ficam):

cd /d "%IOT_DIR%" && docker compose down

Reiniciar tudo:

cd /d "%IOT_DIR%" && docker compose restart

Ver erros do Node-RED (Ctrl+C para sair):

cd /d "%IOT_DIR%" && docker compose logs -f lab06-a-nodered

Mudou alguma opção? Gere de novo na mesma pasta e recrie (o Node-RED e o MQTT só leem login e senhas ao iniciar, por isso o restart):

py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build --remove-orphans && docker compose restart lab06-a-nodered mosquitto

Atualizar as imagens:

cd /d "%IOT_DIR%" && docker compose pull && docker compose build --pull && docker compose up -d

Atualizar agora o material de ELT73A no portal:

cd /d "%IOT_DIR%" && docker compose restart docs

Acompanhar o download do material (Ctrl+C para sair):

cd /d "%IOT_DIR%" && docker compose logs -f docs

Wireshark ao vivo (só MQTT):

cd /d "%IOT_DIR%" && wireshark-ao-vivo.cmd port 1883
Apagar tudo

Remove containers e volumes (Gitea, ntfy, MicroBin, MQTT; o material da disciplina é baixado de novo). Os fluxos em data/ e as telas em fuxa/ ficam na pasta.

cd /d "%IOT_DIR%" && docker compose down -v

Para limpar também os fluxos e as telas, veja Limpar (voltar ao original).

Limpar (voltar ao original)

Tudo o que se faz no Node-RED (fluxos, credenciais dos nós, nós instalados pela paleta, bancos sqlite, projetos) fica em docker\lab06-a\data\lab06-a. O login e a senha ficam fora dela e não mudam com a limpeza. Os nós que já vêm na imagem (dashboard, modbus, opcua...) continuam lá.

Node-RED inteiro (como recém-gerado): apaga a pasta e o gerador a recria.

cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && rmdir /s /q "data\lab06-a" && py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d lab06-a-nodered

Só os fluxos (mantém os nós instalados e os bancos):

cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && (del /q "data\lab06-a\flows.json" "data\lab06-a\flows_cred.json" "data\lab06-a\.flows*.backup" 2>nul & docker compose start lab06-a-nodered)

Só os nós instalados pela paleta (Manage palette):

cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && (rmdir /s /q "data\lab06-a\node_modules" 2>nul & del /q "data\lab06-a\package.json" "data\lab06-a\package-lock.json" "data\lab06-a\.config.nodes.json" 2>nul & docker compose start lab06-a-nodered)

Voltar ao último commit (ex.: o T0 do passo 7): desfaz o que mudou em data\lab06-a desde então.

cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && git checkout -- "data\lab06-a" && git clean -fdq "data\lab06-a" && docker compose start lab06-a-nodered

Guardar um ponto de partida e voltar a ele quando quiser (o nodered-limpo.zip fica na pasta do LAB IoT):

cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && tar -a -cf nodered-limpo.zip "data\lab06-a" && docker compose start lab06-a-nodered

Restaurar:

cd /d "%IOT_DIR%" && docker compose stop lab06-a-nodered && rmdir /s /q "data\lab06-a" && tar -xf nodered-limpo.zip && docker compose start lab06-a-nodered
Zerar o LAB IoT inteiro

Apaga containers, volumes, data\ e fuxa\. O .segredos.json fica: a senha continua a mesma.

cd /d "%IOT_DIR%" && docker compose down -v --remove-orphans && (rmdir /s /q data & rmdir /s /q fuxa) 2>nul

Gerar e subir de novo:

py "%IOT_GEN%" --disciplina elt73a --lab lab06 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%" && cd /d "%IOT_DIR%" && docker compose up -d --build

Depois de limpar, o git status mostra os arquivos apagados: faça um commit (ex.: git commit -am "limpeza") ou deixe como está.

Ponto de commit · T1 (0 pts) #

Hello Docker!

1. Conferir os arquivos
git conferir docker
2. Commit T1 e push
git add docker && git commit -m "T1: Hello Docker!" && 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 1 — SSD1306 no circuito​

Suba o stack do LAB06!

Execute os comandos para subir o stack do LAB06!

1.1 Circuito no Wokwi​

O SSD1306 do Wokwi (board-ssd1306) é um módulo I2C de 4 pinos: GND, VCC, SCL e SDA. No ESP32, o I2C padrão usa GPIO21 = SDA e GPIO22 = SCL. Acrescente o display ao diagram.json do Lab 05:

📂 lab06-grupo-x/
  • └── 🔧diagram.json👈 Edite Aqui
git conferir diagram.json
diagram.json
{
"version": 1,
"author": "elt73a - Lab 06",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-dht22",
"id": "dht1",
"top": -76.5,
"left": 157.8,
"attrs": { "temperature": "24.5", "humidity": "55" }
},
{
"type": "board-ssd1306",
"id": "oled1",
"top": 108.74,
"left": 172.23,
"attrs": { "i2cAddress": "0x3c" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["dht1:VCC", "esp:3V3", "red", []],
["dht1:GND", "esp:GND.2", "black", []],
["dht1:SDA", "esp:15", "green", []],
["oled1:VCC", "esp:3V3", "red", []],
["oled1:GND", "esp:GND.2", "black", []],
["oled1:SDA", "esp:21", "blue", []],
["oled1:SCL", "esp:22", "purple", []]
],
"dependencies": {}
}

1.2 Bibliotecas​

📂 lab06-grupo-x/
  • └── 🔧platformio.ini👈 Edite Aqui
git conferir platformio.ini
platformio.ini
[env:esp32dev]
platform = espressif32@6.9.0 ; versão fixa (Lab 02)
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
adafruit/DHT sensor library@1.4.6
adafruit/Adafruit Unified Sensor@1.1.14
knolleary/PubSubClient@2.8
adafruit/Adafruit SSD1306@2.5.13
adafruit/Adafruit GFX Library@1.11.11

A GFX é a biblioteca de desenho (texto, linhas, retângulos, círculos). A SSD1306 guarda o framebuffer e conversa com o controlador do display pelo I2C.

Ponto de commit · T2 (10 pts) #

Circuito e dependencias do SSD1306

1. Conferir os arquivos
git conferir platformio.ini diagram.json
2. Commit T2 e push
git add platformio.ini diagram.json && git commit -m "T2: Circuito e dependencias do SSD1306" && 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 2 — Tela local​

2.1 Como o SSD1306 desenha​

O display tem 128 × 64 pixels monocromáticos: 1 bit por pixel, 1024 bytes no total. A biblioteca guarda essa imagem num framebuffer na RAM do ESP32:

  • clearDisplay(), print(), drawRect(), fillRect()… só alteram a RAM. São rápidas e nada aparece ainda.
  • display() envia os 1024 bytes pelo I2C para o controlador do display. Isso leva alguns milissegundos e só deve ser feito quando a imagem mudou.

Por isso usamos o mesmo padrão do temporizador do Lab 05: quem detecta a mudança só marca uma flag, e o loop() redesenha.

2.2 Código​

Acrescente ao firmware do Lab 05:

📂 lab06-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (trechos novos da T3)
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_ADDR 0x3C
#define OLED_W 128
#define OLED_H 64

Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1); // -1 = sem pino de reset

float ultimaT = NAN, ultimaH = NAN; // última leitura válida (a tela mostra estes)
bool telaSuja = true; // redesenhar na próxima volta do loop()

// Quadradinho com letra: cheio = conectado, vazado = desconectado
void indicador(int x, const char *letra, bool ok) {
if (ok) {
oled.fillRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_BLACK);
} else {
oled.drawRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_WHITE);
}
oled.setCursor(x + 4, 1);
oled.print(letra);
oled.setTextColor(SSD1306_WHITE);
}

void desenharTela() {
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);

oled.setTextSize(1); // cabeçalho
oled.setCursor(0, 1);
oled.print("LAB06 grupo " GRUPO);
indicador(98, "W", WiFi.status() == WL_CONNECTED);
indicador(114, "M", mqtt.connected());
oled.drawFastHLine(0, 11, OLED_W, SSD1306_WHITE);

oled.setTextSize(2); // temperatura (fonte 12x16)
oled.setCursor(0, 16);
if (isnan(ultimaT)) oled.print("--.-");
else oled.printf("%4.1f", ultimaT);
oled.drawCircle(53, 18, 2, SSD1306_WHITE); // símbolo de grau
oled.setCursor(58, 16);
oled.print("C");

oled.setCursor(0, 36); // umidade + barra
if (isnan(ultimaH)) oled.print("--.-%");
else oled.printf("%4.1f%%", ultimaH);
oled.drawRect(72, 37, 56, 12, SSD1306_WHITE);
if (!isnan(ultimaH)) oled.fillRect(74, 39, (int)(52 * ultimaH / 100.0), 8, SSD1306_WHITE);

oled.setTextSize(1); // rodapé
oled.setCursor(0, 56);
oled.printf("seq %lu int %.0f s", (unsigned long)seq, INTERVALO_S);
oled.display(); // <- só aqui vai para o display
}

// em setup(), depois de dht.begin():
// Wire.begin(OLED_SDA, OLED_SCL);
// if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR))
// Serial.println("[OLED] SSD1306 nao encontrado - confira SDA/SCL/endereco");
// desenharTela();
//
// em lerEPublicar(), depois de validar t e h:
// ultimaT = t; ultimaH = h; telaSuja = true;
//
// no fim de loop():
// if (telaSuja) { telaSuja = false; desenharTela(); }
//
// em conectarMQTT(), logo depois do connect bem-sucedido:
// telaSuja = true; // o indicador "M" muda

Tela esperada depois da primeira leitura:

SSD1306 (128 x 64)
LAB06 grupo a [W] [M]
-------------------------------
24.5 °C
55.0% [██████████ ]
seq 1 int 5 s

As linhas de temperatura e umidade usam a fonte em tamanho 2 (12 × 16 px). [W] e [M] aparecem cheios quando Wi-Fi e MQTT estão conectados.

Preveja antes de rodar
  • P1: por que desenharTela() não pode ser chamada dentro de aoEstourarTemporizador()? E se ela fosse chamada em toda volta do loop(), sem a flag telaSuja? Estime o tempo de um display(): 1024 bytes a 400 kHz, com ~9 bits por byte no I2C. Pense no que acontece com o mqtt.loop().

Anote as previsões e o que observou no README.md.

Evidências: salve o monitor serial com pelo menos 3 leituras em evidencias/t3-serial.txt e uma captura do Wokwi com o display em evidencias/t3-oled.png.

📂 lab06-grupo-x/
  • └── 📂evidencias
    • ├── 📄t3-serial.txt👈 Criar Aqui
    • └── 📄t3-oled.png👈 Criar Aqui
git conferir evidencias/t3-serial.txt evidencias/t3-oled.png
Ponto de commit · T3 (20 pts) #

Tela local no OLED

1. Conferir os arquivos
git conferir src/main.cpp evidencias/t3-serial.txt evidencias/t3-oled.png
2. Commit T3 e push
git add src/main.cpp evidencias/t3-serial.txt evidencias/t3-oled.png && git commit -m "T3: Tela local no OLED" && 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 3 — MQTT nos dois sentidos​

Até aqui o ESP32 só publicava. Agora ele também assina um tópico de comando: o Node-RED (ou qualquer cliente) muda o intervalo de leitura sem regravar o firmware. E a cada redesenho o ESP32 publica o conteúdo da tela em texto, para o dashboard copiar.

3.1 O que muda​

  • INTERVALO_S deixa de ser const: vira float intervaloS, que o comando altera.
  • Callback aoReceberMensagem(): o PubSubClient a chama dentro de mqtt.loop(), ou seja, no contexto do loop(). Ali pode usar Serial e o Ticker à vontade, ao contrário do callback do temporizador.
  • O payload não termina com '\0': copie para um buffer e termine a string antes do atof().
  • Valide o comando. O broker é público: qualquer pessoa pode publicar 0 ou abc no seu tópico.
  • Assine dentro de conectarMQTT(): a sessão é limpa, então depois de uma reconexão o broker não lembra das assinaturas antigas.
  • O JSON das leituras ganha intervalo_s, que confirma ao Node-RED o valor em uso.

3.2 Código completo até aqui​

📂 lab06-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (T4)
// elt73a - Lab 06 (T4): DHT22 + SSD1306 + MQTT nos dois sentidos
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <Ticker.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define GRUPO "a" // troque pela letra do seu grupo
#define DHT_PIN 15
#define DHT_TIPO DHT22
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_ADDR 0x3C
#define OLED_W 128
#define OLED_H 64

const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;

#define BASE "elt73a/lab06/grupo-" GRUPO
const char *TOPICO_DADOS = BASE "/dht";
const char *TOPICO_STATUS = BASE "/status";
const char *TOPICO_OLED = BASE "/oled"; // tela em texto (JSON)
const char *TOPICO_INTERVALO = BASE "/cmd/intervalo"; // Node-RED -> ESP32

DHT dht(DHT_PIN, DHT_TIPO);
Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
Ticker temporizador;

volatile bool leituraPendente = false;
float intervaloS = 5.0; // alterado por MQTT (2..60 s)
uint32_t seq = 0;
float ultimaT = NAN, ultimaH = NAN;
bool telaSuja = true; // redesenhar na próxima volta do loop()
char clientId[32];

void aoEstourarTemporizador() {
leituraPendente = true;
}

// ---------------------------------------------------------------------- OLED
void indicador(int x, const char *letra, bool ok) {
if (ok) {
oled.fillRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_BLACK);
} else {
oled.drawRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_WHITE);
}
oled.setCursor(x + 4, 1);
oled.print(letra);
oled.setTextColor(SSD1306_WHITE);
}

void desenharTela() {
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);

oled.setTextSize(1); // cabeçalho
oled.setCursor(0, 1);
oled.print("LAB06 grupo " GRUPO);
indicador(98, "W", WiFi.status() == WL_CONNECTED);
indicador(114, "M", mqtt.connected());
oled.drawFastHLine(0, 11, OLED_W, SSD1306_WHITE);

oled.setTextSize(2); // temperatura
oled.setCursor(0, 16);
if (isnan(ultimaT)) oled.print("--.-");
else oled.printf("%4.1f", ultimaT);
oled.drawCircle(53, 18, 2, SSD1306_WHITE); // símbolo de grau
oled.setCursor(58, 16);
oled.print("C");

oled.setCursor(0, 36); // umidade + barra
if (isnan(ultimaH)) oled.print("--.-%");
else oled.printf("%4.1f%%", ultimaH);
oled.drawRect(72, 37, 56, 12, SSD1306_WHITE);
if (!isnan(ultimaH)) oled.fillRect(74, 39, (int)(52 * ultimaH / 100.0), 8, SSD1306_WHITE);

oled.setTextSize(1); // rodapé
oled.setCursor(0, 56);
oled.printf("seq %lu int %.0f s", (unsigned long)seq, intervaloS);
oled.display();
}

// ------------------------------------------------------ espelho da tela (T4)
void publicarTelaTexto() {
char t[8] = "--.-", h[8] = "--.-"; // antes da 1ª leitura: sem número
if (!isnan(ultimaT)) snprintf(t, sizeof(t), "%.1f", ultimaT);
if (!isnan(ultimaH)) snprintf(h, sizeof(h), "%.1f", ultimaH);
char payload[200];
snprintf(payload, sizeof(payload),
"{\"linhas\":[\"LAB06 grupo %s\",\"T: %s C\",\"UR: %s %%\","
"\"seq %lu | %.0f s\",\"WiFi %s | MQTT %s\"]}",
GRUPO, t, h, (unsigned long)seq, intervaloS,
WiFi.status() == WL_CONNECTED ? "ok" : "--", mqtt.connected() ? "ok" : "--");
mqtt.publish(TOPICO_OLED, payload);
}

// ---------------------------------------------------------------- comandos
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[16];
size_t n = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, n);
txt[n] = '\0';
Serial.printf("[CMD] %s <- '%s'\r\n", topico, txt);

if (strcmp(topico, TOPICO_INTERVALO) == 0) {
float v = atof(txt);
if (v < 2.0 || v > 60.0) {
Serial.println("[CMD] intervalo fora de 2..60 s - ignorado");
return;
}
intervaloS = v;
temporizador.detach();
temporizador.attach(intervaloS, aoEstourarTemporizador);
Serial.printf("[CMD] novo intervalo: %.1f s\r\n", intervaloS);
telaSuja = true;
}
}

// ------------------------------------------------------------ Wi-Fi e MQTT
void conectarWiFi() {
Serial.printf("[WiFi] conectando a %s", WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA, 6); // canal 6 acelera no Wokwi
while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print('.');
}
Serial.printf("\r\n[WiFi] conectado, IP %s\r\n", WiFi.localIP().toString().c_str());
}

void conectarMQTT() {
while (!mqtt.connected()) {
Serial.printf("[MQTT] conectando a %s como %s ... ", MQTT_HOST, clientId);
if (mqtt.connect(clientId, TOPICO_STATUS, 1, true, "offline")) {
Serial.println("ok");
mqtt.publish(TOPICO_STATUS, "online", true);
mqtt.subscribe(TOPICO_INTERVALO); // (re)assina a cada conexão
telaSuja = true;
} else {
Serial.printf("falhou (rc=%d), nova tentativa em 2 s\r\n", mqtt.state());
delay(2000);
}
}
}

void lerEPublicar() {
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) {
Serial.println("[DHT] falha na leitura (NaN) - descartada");
return;
}
seq++;
ultimaT = t;
ultimaH = h;
char payload[160];
snprintf(payload, sizeof(payload),
"{\"grupo\":\"%s\",\"seq\":%lu,\"t\":%.1f,\"h\":%.1f,\"uptime_ms\":%lu,\"intervalo_s\":%.1f}",
GRUPO, (unsigned long)seq, t, h, (unsigned long)millis(), intervaloS);
bool ok = mqtt.publish(TOPICO_DADOS, payload);
Serial.printf("[PUB] %s %s -> %s\r\n", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
telaSuja = true;
}

void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 06 - DHT22 + SSD1306 + MQTT ===");
dht.begin();

Wire.begin(OLED_SDA, OLED_SCL);
if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
Serial.println("[OLED] SSD1306 nao encontrado - confira SDA/SCL/endereco");
}
desenharTela();

uint64_t mac = ESP.getEfuseMac();
snprintf(clientId, sizeof(clientId), "lab06-%s-%04X", GRUPO, (uint16_t)(mac >> 32));

conectarWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
conectarMQTT();

temporizador.attach(intervaloS, aoEstourarTemporizador);
}

void loop() {
if (WiFi.status() != WL_CONNECTED) conectarWiFi();
if (!mqtt.connected()) conectarMQTT();
mqtt.loop();

if (leituraPendente) {
leituraPendente = false;
lerEPublicar();
}

if (telaSuja) {
telaSuja = false;
desenharTela();
publicarTelaTexto();
}
}

3.3 Testando pelo terminal​

Num terminal, assine todos os tópicos do grupo. Num segundo terminal, mande o comando:

Terminal 1 — Assinar via Docker
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-a/#' -v | tee /ev/t4-mqtt.txt"
Terminal 2 — comandar via Docker
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-a/cmd/intervalo" -m 10
Terminal 2 — fora da faixa (deve ser ignorado)
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab06/grupo-a/cmd/intervalo" -m 1

Saída esperada (trecho; encerre o Terminal 1 com Ctrl+C depois de umas 8 linhas):

📂 lab06-grupo-x/
  • └── 📂evidencias
    • └── 📄t4-mqtt.txt👈 Criar Aqui
git conferir evidencias/t4-mqtt.txt

1. Exemplo de Evidência de Saída:

evidencias/t4-mqtt.txt
elt73a/lab06/grupo-a/status online
elt73a/lab06/grupo-a/dht {"grupo":"a","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt73a/lab06/grupo-a/oled {"linhas":["LAB06 grupo a","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-a/cmd/intervalo 10
elt73a/lab06/grupo-a/oled {"linhas":["LAB06 grupo a","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt73a/lab06/grupo-a/dht {"grupo":"a","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt73a/lab06/grupo-a/cmd/intervalo 1
elt73a/lab06/grupo-a/dht {"grupo":"a","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}

No monitor serial do Wokwi aparecem [CMD] novo intervalo: 10.0 s e, depois, [CMD] intervalo fora de 2..60 s - ignorado.

Preveja antes de rodar

P2: e se o comando fosse publicado com retain (mosquitto_pub -r)? O que acontece quando o ESP32 reinicia? Isso é bom ou ruim para um "intervalo de configuração"? E se o valor retido for inválido, como o 1? (Para apagar uma mensagem retida, publique um payload vazio com -r -n.)

Ponto de commit · T4 (25 pts) #

MQTT nos dois sentidos

1. Conferir os arquivos
git conferir src/main.cpp evidencias/t4-mqtt.txt
2. Commit T4 e push
git add src/main.cpp evidencias/t4-mqtt.txt && git commit -m "T4: MQTT nos dois sentidos" && 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 4 — Node-RED: réplica do OLED e comando do intervalo​

O Node-RED desta aula é mínimo: três fluxos curtos, sem nenhum nó function. Ele só mostra o que o ESP32 publica e devolve o comando do intervalo. Guardar as leituras num banco e consultar o histórico fica para o Lab 08.

No Dashboard 2.0 da stack (My Dashboard, em http://localhost:1880/dashboard), crie uma página Lab 06 (caminho /lab06) com dois grupos: Tela OLED (SSD1306) (largura 6) e ESP32 (largura 3).

Todos os mqtt in usam o mesmo broker do Lab 05 (broker.hivemq.com:1883).

4.1 Réplica do OLED em texto​

mqtt in elt73a/lab06/grupo-x/oled (Output: a parsed JSON object) → ui-template "OLED em texto" (grupo Tela OLED, largura 3, altura 4). O ESP32 manda só o conteúdo, e o navegador desenha com a fonte dele:

ui-template: OLED em texto
<template>
<!-- Réplica em TEXTO: o ESP32 manda só o conteúdo (JSON) e o navegador desenha -->
<div class="oled-txt">
<div v-for="(l, i) in linhas" :key="i">{{ l }}</div>
</div>
</template>

<script>
export default {
computed: {
linhas() {
return this.msg?.payload?.linhas ?? ["(aguardando o ESP32...)"];
},
},
};
</script>

<style scoped>
.oled-txt {
background: #000;
color: #dff3ff;
font-family: "Courier New", monospace;
font-size: 14px;
line-height: 1.35;
padding: 10px 12px;
border-radius: 6px;
border: 6px solid #1c1c1c;
white-space: pre;
}
</style>

4.2 Status e intervalo​

NóConfiguração
mqtt in "status (LWT)"elt73a/lab06/grupo-x/status, Output a String → ui-text "ESP32" (grupo ESP32)
mqtt in "leituras DHT22"elt73a/lab06/grupo-x/dht, Output a parsed JSON object
change "payload = intervalo_s"Set msg.payload to the value msg.payload.intervalo_s
filter "só se mudou"Mode block unless value changes (só deixa passar quando o intervalo muda)
ui-slider "Intervalo de leitura (s)"grupo ESP32, 2 a 60, passo 1, Topic elt73a/lab06/grupo-x/cmd/intervalo, Output on release, pass-through desligado
mqtt outtópico vazio (usa o msg.topic do slider)
Por que o slider não "briga" com o ESP32?

Com pass-through desligado, uma mensagem que chega no slider só move o cursor: ela não sai pelo mqtt out. E o filter só deixa passar o intervalo_s quando o ESP32 confirma um valor novo. Assim o slider mostra o valor em uso, e não só o último pedido.

Abra http://localhost:1880/dashboard/lab06, mova o slider para 10 s e confira:

  • o rodapé do OLED no Wokwi e a réplica em texto mudam para int 10 s;
  • o monitor serial mostra [CMD] novo intervalo: 10.0 s;
  • as leituras passam a chegar a cada 10 s.

Evidências: captura do dashboard em evidencias/t5-dashboard.png e a aba Lab 06 exportada (menu → Export → Current flow) em nodered/flows-lab06.json.

📂 lab06-grupo-x/
  • ├── 📂nodered
    • └── 🔧flows-lab06.json👈 Criar Aqui
  • └── 📂evidencias
    • └── 📄t5-dashboard.png👈 Criar Aqui
git conferir nodered/flows-lab06.json evidencias/t5-dashboard.png
Ponto de commit · T5 (20 pts) #

Node-RED: replica do OLED e comando do intervalo

1. Conferir os arquivos
git conferir nodered/flows-lab06.json evidencias/t5-dashboard.png
2. Commit T5 e push
git add nodered/flows-lab06.json evidencias/t5-dashboard.png && git commit -m "T5: Node-RED: replica do OLED e comando do intervalo" && 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 — framebuffer pixel a pixel​

A réplica em texto da T5 não é a tela do ESP32. Ela não tem o grau desenhado com drawCircle, a barra de umidade, os indicadores [W] [M] nem a fonte grande. Para ver exatamente o que o display mostra, o ESP32 envia o próprio framebuffer: os 1024 bytes que acabaram de ir para o SSD1306 pelo I2C.

Como os 1024 bytes estão organizados​

O SSD1306 divide a tela em 8 páginas de 8 linhas. Cada byte é uma coluna de 8 pixels dentro de uma página, com o bit 0 em cima:

Mapa do framebuffer (128 x 64)
byte 0 .. 127 -> página 0 (linhas 0..7), um byte por coluna x = 0..127
byte 128 .. 255 -> página 1 (linhas 8..15)
...
byte 896 .. 1023 -> página 7 (linhas 56..63)

pixel (x, y) aceso <=> fb[(y / 8) * 128 + x] & (1 << (y % 8))

Como o MQTT/JSON é texto, os bytes viajam em base64: 3 bytes viram 4 caracteres, logo 1024 bytes viram 1368 caracteres.

Requisitos​

  1. Firmware
    • Novo tópico elt73a/lab06/grupo-x/oled/fb.
    • Depois de cada desenharTela(), codificar oled.getBuffer() (1024 bytes) em base64 e publicar nesse tópico.
    • Aumentar o buffer do PubSubClient, que por padrão tem 256 bytes.
  2. Node-RED
    • mqtt in .../oled/fb (Output: a String) → ui-template no grupo Tela OLED, ao lado da réplica em texto da T5, que desenha os pixels num <canvas> (escala 3: 384 × 192 px).
    • Exporte o fluxo de novo por cima de nodered/flows-lab06.json.
  3. Evidências
    • evidencias/t6-oled.png: Wokwi e dashboard lado a lado, mostrando a mesma tela.
    • evidencias/t6-fb.txt: tamanho de uma mensagem do framebuffer, pelo terminal:
Terminal — Assinar via Docker
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab06/grupo-a/oled/fb' -C 1 | wc -c | tee /ev/t6-fb.txt"
evidencias/t6-fb.txt
1369

São 1368 caracteres base64 mais a quebra de linha que o mosquitto_sub acrescenta.

Dicas de API​

Trechos úteis (firmware)
#include "mbedtls/base64.h" // já vem com o core do ESP32

const char *TOPICO_OLED_FB = BASE "/oled/fb";

void publicarFramebuffer() {
static unsigned char b64[1400]; // 1368 + '\0' (static: fora da pilha)
size_t n = 0;
mbedtls_base64_encode(b64, sizeof(b64), &n, oled.getBuffer(), OLED_W * OLED_H / 8);
if (!mqtt.publish(TOPICO_OLED_FB, b64, n, false))
Serial.println("[FB] publish falhou: aumente mqtt.setBufferSize()");
}

// em setup(), antes de conectarMQTT():
// mqtt.setBufferSize(1600); // cabeçalho + tópico + 1368 de payload
Esqueleto do ui-template (complete o desenhar())
<template>
<div class="fb-wrap">
<canvas ref="tela" width="384" height="192" class="oled-fb"></canvas>
</div>
</template>

<script>
export default {
watch: {
msg() {
this.desenhar();
},
}, // roda a cada mensagem nova
mounted() {
this.desenhar();
}, // e quando a página abre
methods: {
desenhar() {
const b64 = this.msg?.payload;
if (typeof b64 !== "string" || !this.$refs.tela) return;
const fb = atob(b64); // string com 1024 "bytes": fb.charCodeAt(i)
const ctx = this.$refs.tela.getContext("2d");
// 1) pinte tudo de preto
// 2) para cada página (0..7), coluna x (0..127) e bit (0..7):
// se o bit estiver aceso, pinte um quadrado 3x3 em (x*3, (pagina*8 + bit)*3)
},
},
};
</script>

<style scoped>
.oled-fb {
display: block;
width: 100%;
max-width: 384px;
aspect-ratio: 2 / 1;
image-rendering: pixelated;
background: #000;
border: 6px solid #1c1c1c;
border-radius: 6px;
}
</style>
Preveja antes de rodar

P3: quantos bytes cada atualização da tela custa no broker em cada versão: texto (.../oled) × framebuffer (.../oled/fb)? Qual das duas daria para guardar num banco e consultar com SQL (como no Lab 08), e qual mostra fielmente o que o usuário vê no display? O que aconteceria se você esquecesse o setBufferSize()? Onde isso apareceria: no serial, no broker ou no dashboard?

📂 lab06-grupo-x/
  • ├── 📂src
    • └── 📄main.cpp👈 Edite Aqui
  • ├── 📂nodered
    • └── 🔧flows-lab06.json👈 Edite Aqui
  • └── 📂evidencias
    • ├── 📄t6-fb.txt👈 Criar Aqui
    • └── 📄t6-oled.png👈 Criar Aqui
git conferir src/main.cpp nodered/flows-lab06.json evidencias/t6-fb.txt evidencias/t6-oled.png
Ponto de commit · T6 (25 pts) #

Framebuffer pixel a pixel no dashboard

1. Conferir os arquivos
git conferir src/main.cpp nodered/flows-lab06.json evidencias/t6-fb.txt evidencias/t6-oled.png
2. Commit T6 e push
git add src/main.cpp nodered/flows-lab06.json evidencias/t6-fb.txt evidencias/t6-oled.png && git commit -m "T6: Framebuffer pixel a pixel no dashboard" && 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.