Laboratório 10
Checklist — SCADA da câmara com FUXA
- LAB IoT do
lab10-xcom a câmara, o fluxo do Lab 09 no Node-RED e os drivers do FUXA instalados (T1) - Três conexões no FUXA (OPC-UA, Modbus TCP e MQTT), em verde e com as tags lendo (T2)
- Sinótico da câmara: estado em cores, valores, barra do aquecedor, setpoint e botões de modo (T3)
- Dois alarmes, testados e reconhecidos (T4)
- Histórico e tendência de T, SP e aquecedor (T5)
- FUXA + Node-RED: o operador escolhe o controlador no FUXA, e um supervisor devolve a câmara ao PI interno se o Node-RED cair (T6)
- Previsões P1–P4 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 20 · T4 15 · T5 15 ·
T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
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.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-a"
2. Gere o LAB IoT do grupo em docker\lab10-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo a --sem-gitea --sem-microbin --sem-ntfy --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 lab10-a-nodered && (del /q "data\lab10-a\flows.json" "data\lab10-a\flows_cred.json" "data\lab10-a\.flows*.backup" 2>nul & docker compose start lab10-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-b"
2. Gere o LAB IoT do grupo em docker\lab10-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo b --sem-gitea --sem-microbin --sem-ntfy --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 lab10-b-nodered && (del /q "data\lab10-b\flows.json" "data\lab10-b\flows_cred.json" "data\lab10-b\.flows*.backup" 2>nul & docker compose start lab10-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-c"
2. Gere o LAB IoT do grupo em docker\lab10-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo c --sem-gitea --sem-microbin --sem-ntfy --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 lab10-c-nodered && (del /q "data\lab10-c\flows.json" "data\lab10-c\flows_cred.json" "data\lab10-c\.flows*.backup" 2>nul & docker compose start lab10-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-d"
2. Gere o LAB IoT do grupo em docker\lab10-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo d --sem-gitea --sem-microbin --sem-ntfy --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 lab10-d-nodered && (del /q "data\lab10-d\flows.json" "data\lab10-d\flows_cred.json" "data\lab10-d\.flows*.backup" 2>nul & docker compose start lab10-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-e"
2. Gere o LAB IoT do grupo em docker\lab10-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo e --sem-gitea --sem-microbin --sem-ntfy --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 lab10-e-nodered && (del /q "data\lab10-e\flows.json" "data\lab10-e\flows_cred.json" "data\lab10-e\.flows*.backup" 2>nul & docker compose start lab10-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-f"
2. Gere o LAB IoT do grupo em docker\lab10-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo f --sem-gitea --sem-microbin --sem-ntfy --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 lab10-f-nodered && (del /q "data\lab10-f\flows.json" "data\lab10-f\flows_cred.json" "data\lab10-f\.flows*.backup" 2>nul & docker compose start lab10-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-g"
2. Gere o LAB IoT do grupo em docker\lab10-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo g --sem-gitea --sem-microbin --sem-ntfy --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 lab10-g-nodered && (del /q "data\lab10-g\flows.json" "data\lab10-g\flows_cred.json" "data\lab10-g\.flows*.backup" 2>nul & docker compose start lab10-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-h"
2. Gere o LAB IoT do grupo em docker\lab10-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo h --sem-gitea --sem-microbin --sem-ntfy --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 lab10-h-nodered && (del /q "data\lab10-h\flows.json" "data\lab10-h\flows_cred.json" "data\lab10-h\.flows*.backup" 2>nul & docker compose start lab10-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-i"
2. Gere o LAB IoT do grupo em docker\lab10-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo i --sem-gitea --sem-microbin --sem-ntfy --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 lab10-i-nodered && (del /q "data\lab10-i\flows.json" "data\lab10-i\flows_cred.json" "data\lab10-i\.flows*.backup" 2>nul & docker compose start lab10-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-j"
2. Gere o LAB IoT do grupo em docker\lab10-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo j --sem-gitea --sem-microbin --sem-ntfy --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 lab10-j-nodered && (del /q "data\lab10-j\flows.json" "data\lab10-j\flows_cred.json" "data\lab10-j\.flows*.backup" 2>nul & docker compose start lab10-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-k"
2. Gere o LAB IoT do grupo em docker\lab10-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo k --sem-gitea --sem-microbin --sem-ntfy --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 lab10-k-nodered && (del /q "data\lab10-k\flows.json" "data\lab10-k\flows_cred.json" "data\lab10-k\.flows*.backup" 2>nul & docker compose start lab10-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-l"
2. Gere o LAB IoT do grupo em docker\lab10-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo l --sem-gitea --sem-microbin --sem-ntfy --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 lab10-l-nodered && (del /q "data\lab10-l\flows.json" "data\lab10-l\flows_cred.json" "data\lab10-l\.flows*.backup" 2>nul & docker compose start lab10-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-m"
2. Gere o LAB IoT do grupo em docker\lab10-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo m --sem-gitea --sem-microbin --sem-ntfy --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 lab10-m-nodered && (del /q "data\lab10-m\flows.json" "data\lab10-m\flows_cred.json" "data\lab10-m\.flows*.backup" 2>nul & docker compose start lab10-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab10-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-x"
2. Gere o LAB IoT do grupo em docker\lab10-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo x --sem-gitea --sem-microbin --sem-ntfy --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 lab10-x-nodered && (del /q "data\lab10-x\flows.json" "data\lab10-x\flows_cred.json" "data\lab10-x\.flows*.backup" 2>nul & docker compose start lab10-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Nos Labs 08 e 09, o Node-RED fez o papel de SCADA: cada leitura, cada escala e cada botão foram programados em nós e funções. Funciona, mas não é assim que se supervisiona uma fábrica. Lá, o operador olha para um sinótico desenhado num software de SCADA/IHM, onde conexões, tags, alarmes e histórico são configurados, e não programados.
Nesta aula, você monta o SCADA da mesma câmara climática no FUXA, um SCADA web de código aberto que já vem no LAB IoT. Tudo o que você aprendeu nos Labs 08 e 09 reaparece, agora como configuração:
| No Lab 08/09 (Node-RED) | No FUXA |
|---|---|
nó de configuração (modbus-client, OpcUa-Endpoint, mqtt-broker) | conexão (Connection) |
endereço lido por um nó (IR0, ns=2;s=Camara.temp, chave do JSON) | tag |
| function "÷10" | campo Divisor da tag |
| debug, ui-table, ui-chart | sinótico, tendência |
| PI externo (Lab 09, T6) | continua no Node-RED; o FUXA escolhe quem controla e vigia |
Objetivos
- Configurar um SCADA: drivers, conexões e tags.
- Comparar como cada protocolo é endereçado num SCADA: NodeId (OPC-UA), registrador base 1 com divisor (Modbus) e chave de JSON (MQTT).
- Desenhar um sinótico: formas e cores ligadas ao estado, valores, barras e comandos.
- Configurar alarmes com nível, texto e reconhecimento.
- Registrar histórico e montar uma tendência.
- (Integrador) Dividir o trabalho entre SCADA e controlador e implementar um supervisor de falha do controlador externo.
Material
- O LAB IoT do
lab10-x(gerado pelogen_iot_aluno.py, sem--sem-fuxa): mosquitto, Node-RED e FUXA. - O simulador
camara-sim, na pastacamara-sim/do repositório do grupo. - O fluxo do Lab 09 (
nodered/flows-lab09.json, no repositório do Lab 09). - Acesso à internet no primeiro uso: os drivers do FUXA são baixados do npm.
O FUXA tem editor (/editor) e runtime (a tela do operador) no mesmo servidor. As
conexões rodam no servidor, e não no navegador: 10 operadores com a tela aberta não
multiplicam o tráfego com a câmara. A aula não usa usuários e permissões, relatórios,
receitas nem o Node-RED embutido do FUXA. Também fica de fora o driver S7: ele não resolve
nomes de host e exigiria o IP do contêiner.
Clonar o repositório do grupo
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-a/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-a.git && cd lab10-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-b/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-b.git && cd lab10-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-c/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-c.git && cd lab10-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-d/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-d.git && cd lab10-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-e/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-e.git && cd lab10-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-f/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-f.git && cd lab10-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-g/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-g.git && cd lab10-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-h/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-h.git && cd lab10-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-i/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-i.git && cd lab10-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-j/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-j.git && cd lab10-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-k/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-k.git && cd lab10-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-l/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-l.git && cd lab10-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-m/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-m.git && cd lab10-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-x/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-x.git && cd lab10-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-p/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-p.git && cd lab10-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab10-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab10-grupo-n/commits/main/
- Acessos: ACESSO-LAB10.md
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/lab10-grupo-n.git && cd lab10-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-n" && code . --profile "ESP32IO"
Envie o link do repositório do seu grupo no Moodle:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
Repositório do Grupo A para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo B para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo C para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo D para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo E para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo F para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo G para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo H para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo I para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo J para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo K para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo L para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo M para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo X para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo P para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo N para Laboratório 10:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Câmara, Node-RED e drivers do FUXA · 10 pts
- T2 — Conexões e tags · 20 pts
- T3 — Sinótico da câmara · 20 pts
- T4 — Alarmes · 15 pts
- T5 — Histórico e tendência · 15 pts
- T6 — FUXA + Node-RED: quem controla e quem vigia · 20 pts
Estrutura de Arquivos do Projeto
- ├── 📂camara-sim
- ├── 🚀docker-compose.yml👈 Verificar
- ├── 🚀docker-compose.lab.yml👈 Verificar
- ├── 📄.env.example👈 Verificar
- └── 📄.env👈 Criar Aqui
- ├── 📂fuxa
- └── 🔧projeto-lab10.json👈 Criar Aqui
- ├── 📂nodered
- └── 🔧flows-lab10.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t1-enderecos.txt👈 Criar Aqui
- ├── 📄t1-plugins.png👈 Criar Aqui
- ├── 📄t2-conexoes.png👈 Criar Aqui
- ├── 📄t3-sinotico.png👈 Criar Aqui
- ├── 📄t4-alarmes.png👈 Criar Aqui
- ├── 📄t5-tendencia.png👈 Criar Aqui
- ├── 📄t6-fallback.png👈 Criar Aqui
- └── 📄t6-log.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Troque o x pela letra do seu grupo em todos os nomes abaixo.
| O quê | Valor |
|---|---|
| Câmara (host na rede) | lab10-x-camara |
| Telemetria da câmara (MQTT) | elt85b/lab10/grupo-x/camara/telemetria |
| Estado do PI externo (T6) | elt85b/lab10/grupo-x/scada/pi |
| Node-RED | http://localhost/lab10-x/ (contêiner lab10-x-nodered) |
| FUXA: editor / runtime | http://localhost/fuxa/lab10-x/editor · http://localhost/fuxa/lab10-x/ (contêiner lab10-x-fuxa) |
| Login do FUXA | o usuário e a senha do grupo (credenciais.txt do LAB IoT) |
O projeto do FUXA fica dentro do LAB IoT (pasta fuxa/lab10-x/ dele). O que vai para o
repositório é a exportação: no menu do projeto (ícone de disquete), Save Project As...
baixa o arquivo; salve-o como fuxa/projeto-lab10.json. Exporte de novo ao fim de cada
tarefa.
Parte 1 — Câmara, Node-RED e drivers do FUXA
1.1 A câmara e o fluxo do Lab 09
O mesmo do Lab 09 (Parte 1), com os nomes do Lab 10:
- Câmara: o
.envda pastacamara-sim/comGRUPO=lab10-x,MQTT_BASE=elt85b/lab10/grupo-x/camara,LAB_REDE=lab10-x_labneteSIM_SPEED=5, e odocker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build.
- └── 📂camara-sim
- └── 📄.env👈 Criar Aqui
git conferir camara-sim/.env
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Arquivo .env:
GRUPO=lab10-a
MQTT_BASE=elt85b/lab10/grupo-a/camara
LAB_REDE=lab10-a_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-a\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-a-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-a
if not exist evidencias mkdir evidencias
docker network inspect lab10-a_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-b
MQTT_BASE=elt85b/lab10/grupo-b/camara
LAB_REDE=lab10-b_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-b\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-b-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-b
if not exist evidencias mkdir evidencias
docker network inspect lab10-b_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-c
MQTT_BASE=elt85b/lab10/grupo-c/camara
LAB_REDE=lab10-c_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-c\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-c-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-c
if not exist evidencias mkdir evidencias
docker network inspect lab10-c_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-d
MQTT_BASE=elt85b/lab10/grupo-d/camara
LAB_REDE=lab10-d_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-d\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-d-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-d
if not exist evidencias mkdir evidencias
docker network inspect lab10-d_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-e
MQTT_BASE=elt85b/lab10/grupo-e/camara
LAB_REDE=lab10-e_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-e\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-e-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-e
if not exist evidencias mkdir evidencias
docker network inspect lab10-e_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-f
MQTT_BASE=elt85b/lab10/grupo-f/camara
LAB_REDE=lab10-f_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-f\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-f-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-f
if not exist evidencias mkdir evidencias
docker network inspect lab10-f_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-g
MQTT_BASE=elt85b/lab10/grupo-g/camara
LAB_REDE=lab10-g_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-g\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-g-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-g
if not exist evidencias mkdir evidencias
docker network inspect lab10-g_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-h
MQTT_BASE=elt85b/lab10/grupo-h/camara
LAB_REDE=lab10-h_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-h\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-h-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-h
if not exist evidencias mkdir evidencias
docker network inspect lab10-h_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-i
MQTT_BASE=elt85b/lab10/grupo-i/camara
LAB_REDE=lab10-i_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-i\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-i-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-i
if not exist evidencias mkdir evidencias
docker network inspect lab10-i_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-j
MQTT_BASE=elt85b/lab10/grupo-j/camara
LAB_REDE=lab10-j_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-j\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-j-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-j
if not exist evidencias mkdir evidencias
docker network inspect lab10-j_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-k
MQTT_BASE=elt85b/lab10/grupo-k/camara
LAB_REDE=lab10-k_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-k\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-k-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-k
if not exist evidencias mkdir evidencias
docker network inspect lab10-k_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-l
MQTT_BASE=elt85b/lab10/grupo-l/camara
LAB_REDE=lab10-l_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-l\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-l-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-l
if not exist evidencias mkdir evidencias
docker network inspect lab10-l_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-m
MQTT_BASE=elt85b/lab10/grupo-m/camara
LAB_REDE=lab10-m_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-m\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-m-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-m
if not exist evidencias mkdir evidencias
docker network inspect lab10-m_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-x
MQTT_BASE=elt85b/lab10/grupo-x/camara
LAB_REDE=lab10-x_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-x\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-x-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-x
if not exist evidencias mkdir evidencias
docker network inspect lab10-x_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-p
MQTT_BASE=elt85b/lab10/grupo-p/camara
LAB_REDE=lab10-p_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-p\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-p-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-p
if not exist evidencias mkdir evidencias
docker network inspect lab10-p_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Arquivo .env:
GRUPO=lab10-n
MQTT_BASE=elt85b/lab10/grupo-n/camara
LAB_REDE=lab10-n_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
2. Subir:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-n\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-n-camara
3. Quem está na rede:
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-n
if not exist evidencias mkdir evidencias
docker network inspect lab10-n_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
- Node-RED: importe o
nodered/flows-lab10.jsondo repositório do Lab 09, chame a aba de Lab 10 e troquelab09porlab10nos quatro nós de configuração (Modbus TCP, Modbus RTU/TCP, S7 e OPC-UA), nos tópicos MQTT e no caminho do SQLite (/data/sqlite/lab10.sqlite). Use Ctrl+F para achar o que sobrou. Deploy e confira o painel emhttp://localhost/lab10-x/dashboard/lab10.
1.2 Drivers do FUXA
Abra o editor do FUXA (http://localhost/fuxa/lab10-x/editor) e entre com o usuário do grupo.
No FUXA, só o MQTT vem instalado: Modbus e OPC-UA são plugins, baixados do npm na primeira
vez. Na engrenagem (Setup) ▸ Plugins, instale:
| Plugin | Protocolo |
|---|---|
modbus-serial | Modbus TCP e RTU |
node-opcua | OPC-UA (o maior: leva cerca de 1 min) |
Instale a versão que a tela de plugins mostra: é o próprio FUXA que a define (no FUXA 1.3.5,
modbus-serial 8.0.19 e node-opcua 2.149.0).
Os plugins ficam na pasta fuxa/lab10-x/pkg/ do LAB IoT: sobrevivem a um docker compose down.
Evidência: evidencias/t1-plugins.png, a tela de plugins com os dois instalados.
- ├── 📂camara-sim
- └── 📄.env👈 Criar Aqui
- ├── 📂nodered
- └── 🔧flows-lab10.json👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-enderecos.txt👈 Criar Aqui
- └── 📄t1-plugins.png👈 Criar Aqui
git conferir camara-sim/.env nodered/flows-lab10.json evidencias/t1-enderecos.txt evidencias/t1-plugins.png
Câmara, Node-RED e drivers do FUXA
git conferir camara-sim/.env nodered/flows-lab10.json evidencias/t1-enderecos.txt evidencias/t1-plugins.png
git add camara-sim/.env nodered/flows-lab10.json evidencias/t1-enderecos.txt evidencias/t1-plugins.png && git commit -m "T1: Câmara, Node-RED e drivers do FUXA" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 2 — Conexões e tags
No FUXA, uma conexão é um equipamento, e uma tag é uma variável dele. Telas, alarmes, histórico e scripts só enxergam tags. Em Setup ▸ Connections, o botão + cria uma conexão; o ícone de corrente 🔗 de cada conexão abre a lista de tags, onde o + cria uma tag. A coluna Value mostra o valor ao vivo: use-a para conferir cada tag.
Crie as três conexões, todas com Polling 1 sec:
| Name | Type | Endereço | Outros campos |
|---|---|---|---|
Camara OPC-UA | OPCUA | opc.tcp://lab10-x-camara:4840/ | Without Security |
Camara Modbus | ModbusTCP | Slave IP and Port lab10-x-camara:502 | Connection options TcpPort, Slave ID 1 |
Broker MQTT | MQTTclient | mqtt://mosquitto:1883 | Without Security |
São os mesmos endereços dos nós de configuração do Node-RED (Lab 08, seção 1.3): o FUXA está na mesma rede.
2.1 OPC-UA: o servidor diz o que tem
Na lista de tags da Camara OPC-UA, o + abre o navegador do servidor (o browse do
Lab 08). Expanda Objects ▸ Camara e marque:
| Pasta | Variáveis |
|---|---|
Medicoes | temp, umid, sp_efetivo |
Atuadores | aquecedor_pwm |
Estado | estado, estado_txt, alarme |
Comandos | modo, setpoint |
Simulacao | falha_dht |
Cada tag fica com o NodeId como endereço e o tipo que o servidor declara. É o caminho mais simples: nada de mapa de registradores.
O servidor recusa uma escrita com tipo errado (BadTypeMismatch, Lab 08), mas o FUXA não
mostra esse erro: o valor simplesmente não muda. Mantenha o tipo que o navegador trouxe.
2.2 Modbus TCP: endereço base 1 e divisor
Na Camara Modbus, crie as tags à mão, com o mapa do Lab 09. Atenção: no FUXA, o campo
Address offset vai de 1 a 65536. O registrador 0 do mapa é o endereço 1 no FUXA, o
IR12 é o 13, e assim por diante. O Divisor faz o papel da function "÷10" do Lab 08 (÷ na
leitura, × na escrita).
| Tagname | Register | Address offset | Type | Divisor | No Lab 09 |
|---|---|---|---|---|---|
IR0 temp x10 | Input Registers | 1 | Int16 | 10 | r[0] / 10 |
IR12 temp float | Input Registers | 13 | Float32 | f32(12) | |
HR1 modo | Holding Registers | 2 | UInt16 | HR1 |
IR0 temp x10 e IR12 temp float devem mostrar a mesma temperatura. Se não mostrarem, o
endereço está deslocado de um.
2.3 MQTT: uma chave do JSON
Na Broker MQTT, o + abre o assinante de tópicos. Em Topic path, coloque
elt85b/lab10/grupo-x/camara/telemetria, escolha json, clique Subscribe e marque a chave
temp (nome telemetria temp). A chave vira uma tag com o tópico como endereço.
Evidências: evidencias/t2-conexoes.png (Setup ▸ Connections com as três conexões em
verde) e o projeto exportado em fuxa/projeto-lab10.json.
P1: um colega configurou IR12 temp float com Address offset 12, em vez de 13. Quais
registradores da câmara o FUXA lê nesse caso? Olhe o mapa do Lab 09: o que é o IR11? Que tipo
de número aparece: próximo da temperatura, enorme ou minúsculo? E se ele tivesse escolhido
Float32MLE (ordem de palavras trocada, a P1 do Lab 09) com o endereço certo? Teste os dois.
- ├── 📂fuxa
- └── 🔧projeto-lab10.json👈 Criar Aqui
- └── 📂evidencias
- └── 📄t2-conexoes.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t2-conexoes.png
Conexões e tags
git conferir fuxa/projeto-lab10.json evidencias/t2-conexoes.png
git add fuxa/projeto-lab10.json evidencias/t2-conexoes.png && git commit -m "T2: Conexões e tags" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.
Parte 3 — Sinótico da câmara
Um sinótico mostra o processo, e não uma lista de números: o operador entende o estado da câmara num relance e age sem procurar.
3.1 Como um widget se liga a uma tag
No editor, crie a tela Camara (painel Views ▸ +). Desenhe com as ferramentas de General e Controls. Com o objeto selecionado, Property (ou duplo clique) abre a ligação:
- Tag: a variável que o widget mostra ou que dirige a animação;
- Ranges: faixas de valor → cor (formas, botões) ou unidade e casas (valores);
- Events: o que acontece no clique (Click ▸ Set Value).
3.2 O que a tela precisa ter
| Elemento | Ferramenta | Tag | Configuração |
|---|---|---|---|
| Corpo da câmara | retângulo (General) | estado | Ranges: 0 cinza · 1 laranja · 2 azul · 3 verde · 4 vermelho |
| T, UR, estado | Value | temp, umid, estado_txt | unidade °C / %, 1 casa |
| Aquecedor | Progress (vertical) | aquecedor_pwm | 0 a 100 |
| Setpoint | Input | setpoint (OPC-UA) | numérico, mín. 20, máx. 55 |
| Botões ON/OFF, PI interno, PI Node-RED | Button | modo (OPC-UA) | Click ▸ Set Value 1, 2, 0; Ranges: o botão do modo atual fica azul |
| Falha do DHT22 | Button | falha_dht | Click ▸ Set Value 1 / outro botão 0 |
| Temperatura por protocolo | 3 × Value | temp, IR12 temp float, telemetria temp | a mesma câmara por três portas (Lab 08) |
Quando o valor sai de todas as faixas de um botão, o FUXA não volta à cor original: ele
mantém a última cor aplicada. Por isso, cada botão de modo precisa de uma faixa para cada
valor possível, 0, 1 e 2 (a do próprio modo azul, as outras brancas).
Em Setup ▸ Layout, defina a tela inicial (Start Camara) e mostre os alarmes no
cabeçalho (o sino com o contador, para a T4).
Abra o runtime (http://localhost/fuxa/lab10-x/) e teste: mude o setpoint e troque o modo.
Os botões acompanham o modo mesmo quando outro programa o muda: escreva o modo pelo
dashboard do Node-RED (Lab 09) e veja o FUXA acompanhar.
Evidência: evidencias/t3-sinotico.png, com a câmara aquecendo (laranja), e o projeto
exportado.
- ├── 📂fuxa
- └── 🔧projeto-lab10.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t3-sinotico.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t3-sinotico.png
Sinótico da câmara
git conferir fuxa/projeto-lab10.json evidencias/t3-sinotico.png
git add fuxa/projeto-lab10.json evidencias/t3-sinotico.png && git commit -m "T3: Sinótico da câmara" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.
Parte 4 — Alarmes
Um alarme é uma condição anormal que exige ação do operador: tem prioridade, texto, instante de entrada e de saída e reconhecimento (ack). Em Setup ▸ Alarms ▸ +, escolha a tag e preencha o nível, a faixa min–max, o texto e o modo de reconhecimento.
| Alarme | Tag | Nível | Faixa | Texto | Ack |
|---|---|---|---|---|---|
Temperatura | temp | High | 45–200 | Temperatura alta (>= 45 °C) | Floating |
Sensor DHT22 | alarme | High High | 2–3 | Falha do sensor DHT22 | Ack by active Alarm allowed |
- O
alarmeda câmara é um campo de bits (Lab 09): bit 0 = sobretemperatura, bit 1 = sensor. Valor 2 ou 3 significa "sensor com falha". - Em ambos, Time in Min-Max range
1s e Check interval1s. - Ack mode: Floating some sozinho quando a condição acaba; Ack by active Alarm allowed fica na lista até o operador reconhecer.
Teste:
- Modo ON/OFF e setpoint 50 °C: quando T passa de 45 °C, entra "Temperatura alta".
- Clique Falha do DHT22: a câmara vai para ALARME (vermelho), e entra "Falha do sensor". Tire a falha.
- No sino do cabeçalho, abra a lista e reconheça (✔) o alarme do sensor.
Evidência: evidencias/t4-alarmes.png com a lista de alarmes aberta.
P2: com o setpoint em 45 °C e o PI interno, a temperatura oscila ±0,1 °C em torno de 45 °C. O que acontece com o alarme "Temperatura alta" (Floating, 1 s na faixa)? Ele entra e sai quantas vezes por minuto? Por que normas de alarme (ISA-18.2) pedem uma banda morta no limite? Como você a imitaria no FUXA, que só tem faixas min–max?
- ├── 📂fuxa
- └── 🔧projeto-lab10.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t4-alarmes.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t4-alarmes.png
Alarmes
git conferir fuxa/projeto-lab10.json evidencias/t4-alarmes.png
git add fuxa/projeto-lab10.json evidencias/t4-alarmes.png && git commit -m "T4: Alarmes" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Parte 5 — Histórico e tendência
No Lab 09, o histórico foi programado: tabela, INSERT e consultas no SQLite. O FUXA tem
um historiador próprio (o DAQ), que só precisa ser ligado em cada tag.
- Na lista de tags, o menu ⋮ ▸ Tag options de cada tag tem Registration Enabled (grava
a tag), Save if changed (grava quando o valor muda) e Save value interval (grava
também a cada N s, mesmo parado; use 60). Ligue o registro em
temp,sp_efetivoeaquecedor_pwm. - Setup ▸ Line charts ▸ +: gráfico
Camaracomtemp(vermelho),sp_efetivo(laranja) eaquecedor_pwm(cinza, no eixo Y2, em %). - Crie a tela Tendencia com um Chart: Chart to show
Camara, Show mode Realtime, Max minutes 15 e Load history ligado. Acrescente-a ao menu (Setup ▸ Layout). O Chart herda a cor de preenchimento selecionada no editor: se ela estiver preta, o fundo fica preto e os eixos somem. Escolha um preenchimento claro antes de desenhar, ou mude a cor de fundo nas propriedades do gráfico.
Faça um degrau (35 → 40 °C, PI interno) e veja a resposta na tendência.
Evidência: evidencias/t5-tendencia.png, com o degrau visível.
P3: na tendência, quando você muda o setpoint de 35 para 40 °C, a linha do SP aparece como uma rampa inclinada, e não como um degrau. Por quê? (Dica: quando o DAQ gravou o SP, e como o gráfico liga dois pontos?) Compare com o gráfico do Lab 09, alimentado a cada conjunto do OPC-UA.
- ├── 📂fuxa
- └── 🔧projeto-lab10.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t5-tendencia.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t5-tendencia.png
Histórico e tendência
git conferir fuxa/projeto-lab10.json evidencias/t5-tendencia.png
git add fuxa/projeto-lab10.json evidencias/t5-tendencia.png && git commit -m "T5: Histórico e tendência" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T5.
Projeto integrador — FUXA + Node-RED: quem controla e quem vigia
No Lab 09, o PI externo era ligado por um switch no dashboard do próprio Node-RED, e a P4 mostrou o problema: se o Node-RED cai com o aquecedor ligado, ninguém desliga. Agora as responsabilidades se separam:
| Quem | Faz |
|---|---|
| Câmara | executa: obedece ao modo (0 MANUAL, 1 ON/OFF, 2 PI interno) |
| Node-RED | controla: roda o PI sempre que a câmara está em modo 0 e publica um sinal de vida |
| FUXA | opera e vigia: o operador escolhe o modo; um script devolve a câmara ao modo 2 se o Node-RED parar |
Requisitos
-
Node-RED: o PI obedece ao modo. Na function "PI" do Lab 09, troque o começo (a parte que olha o
pi_ativodo switch):function: PI — início (o resto é igual ao Lab 09)// Lab 10: atua sempre que a câmara está em modo 0 (MANUAL), não importa quem escolheu// o modo (FUXA, dashboard, Modbus...). Fora do modo 0, fica parado.const p = msg.payload;if (p.modo !== 0) {context.set("I", 0);context.set("t0", null);node.status({fill: "grey",shape: "ring",text: `parado (modo ${p.modo})`,});return [null, null];} -
Node-RED: sinal de vida. Ligue a 2ª saída do PI (diagnóstico) a esta function e a um mqtt out
elt85b/lab10/grupo-x/scada/pi:function: estado do PI -> SCADA// Estado do PI -> FUXA. O 'seq' é o sinal de vida que o supervisor do FUXA vigia.const seq = (context.get("seq") || 0) + 1;context.set("seq", seq);const p = msg.payload;msg.payload = {seq,e: Number(p.e.toFixed(3)),I: Number(p.I.toFixed(2)),aq: p.aq,ts: Date.now(),};return msg; -
FUXA: tags do PI. Na
Broker MQTT, tópicoelt85b/lab10/grupo-x/scada/pi, json, chavesseq(nomepi seq),e(pi erro) eaq(pi aquecedor). Mostrepi erroepi aquecedorno sinótico, ao lado dos botões de modo. -
FUXA: supervisor. Em Setup ▸ Scripts ▸ +: nome
supervisor_pi_externo, Execute mode Server, e em Script scheduling Loop with interval de 2 s:script: supervisor_pi_externo// Supervisor do PI externo: roda no SERVIDOR do FUXA a cada 2 s.// Se a câmara está em MANUAL (modo 0) e o Node-RED parou de publicar .../scada/pi// (o seq não muda há mais de 10 s), volta ao PI interno (modo 2) pelo Modbus.const LIMITE_S = 10;// tags pelo NOME (tag, conexão): os nomes têm de ser exatamente os da T2const MODO = $getTagId("modo", "Camara OPC-UA"); // leitura do modoconst MODO_MB = $getTagId("HR1 modo", "Camara Modbus"); // escrita do fallbackconst SEQ = $getTagId("pi seq", "Broker MQTT"); // sinal de vida do Node-REDconst modo = Number($getTag(MODO));const seq = $getTag(SEQ);const agora = Date.now();const wd =globalThis.wd ||(globalThis.wd = { seq: seq, desde: agora, modo: modo, disparou: false });// recomeça a contar quando chega seq novo OU quando o operador acabou de escolher o modo 0if (seq !== wd.seq || (modo === 0 && wd.modo !== 0)) {wd.seq = seq;wd.desde = agora;wd.disparou = false;}wd.modo = modo;const idade = Math.round((agora - wd.desde) / 1000);if (modo === 0 && idade > LIMITE_S && !wd.disparou) {wd.disparou = true; // uma vez só (a leitura do modo demora um ciclo)$setTag(MODO_MB, 2); // fallback: PI internoconsole.log("supervisor: PI externo sem resposta ha " + idade + " s -> modo 2",);}O fallback escreve pelo Modbus de propósito: no log da câmara,
opcua: modo = …é o operador emodbus: modo = 2é o supervisor. -
Experimento (setpoint 40 °C):
-
No FUXA, clique PI Node-RED:
pi erroepi aquecedormudam a cada ~2 s. -
Pare o controlador e cronometre: em 10 a 14 s, a câmara volta ao PI interno (o botão "PI interno" acende).
Terminal (cmd)docker stop lab10-x-nodered -
docker start lab10-x-nodered, espere o Node-RED subir e clique PI Node-RED de novo.
-
-
Evidências:
evidencias/t6-fallback.png: o sinótico depois do fallback;evidencias/t6-log.txt: as escritas de modo vistas pela câmara;
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Log das escritas de modo:
docker logs lab10-a-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-b-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-c-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-d-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-e-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-f-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-g-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-h-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-i-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-j-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-k-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-l-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-m-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-x-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-p-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
1. Log das escritas de modo:
docker logs lab10-n-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
[14:25:49] [cmd] opcua: modo = 0
[14:26:32] [cmd] modbus: modo = 2
[14:26:57] [cmd] opcua: modo = 0
nodered/flows-lab10.jsonefuxa/projeto-lab10.jsonexportados de novo;- no
README.md, as respostas de P1 a P4.
P4: (a) o que acontece se o operador clicar ON/OFF no FUXA enquanto o PI externo está agindo? (b) E se o FUXA cair com a câmara em modo 0 e, depois, o Node-RED também cair? (c) Com base na P4 do Lab 09: o supervisor no FUXA substitui um watchdog dentro do equipamento? Onde cada proteção deve ficar?
- ├── 📂nodered
- └── 🔧flows-lab10.json👈 Edite Aqui
- ├── 📂fuxa
- └── 🔧projeto-lab10.json👈 Edite Aqui
- ├── 📂evidencias
- ├── 📄t6-fallback.png👈 Criar Aqui
- └── 📄t6-log.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir nodered/flows-lab10.json fuxa/projeto-lab10.json evidencias/t6-fallback.png evidencias/t6-log.txt README.md
FUXA + Node-RED: quem controla e quem vigia
git conferir nodered/flows-lab10.json fuxa/projeto-lab10.json evidencias/t6-fallback.png evidencias/t6-log.txt README.md
git add nodered/flows-lab10.json fuxa/projeto-lab10.json evidencias/t6-fallback.png evidencias/t6-log.txt README.md && git commit -m "T6: FUXA + Node-RED: quem controla e quem vigia" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.
Referência rápida
| Problema | O que fazer |
|---|---|
| Conexão OPC-UA ou Modbus vermelha logo de início | o plugin (node-opcua, modbus-serial) não foi instalado (T1) |
| Conexão vermelha com o plugin instalado | o endereço é o nome na rede (lab10-x-camara), e não localhost; confira com o docker network inspect da T1 |
IR0 temp x10 e IR12 temp float diferentes | Address offset deslocado de um: no FUXA, o registrador 0 é o endereço 1 (P1) |
| Escrevi no setpoint e nada mudou | tipo da tag OPC-UA trocado; mantenha o que o navegador trouxe |
| Botão de modo continua azul | falta uma faixa para cada valor do modo (0, 1, 2) |
| O supervisor não faz nada | os nomes no $getTagId têm de ser idênticos aos das tags e das conexões; o script está em modo Server e com Loop |
| O editor do FUXA pede login | use o usuário e a senha do grupo (credenciais.txt) |
Logout do seu ambiente dev, git e gh
Ao terminar, pare os containers:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Para o git "esquecer" suas informações salvas:
git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
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.