Laboratório 09
Checklist — Modbus, S7 e OPC-UA a fundo: painel SCADA e controle pela rede
-
camara-simdo Lab 09 na rede do stack, endereços conferidos e o fluxo do Lab 08 reaproveitado (T1) - Modbus completo: mapa inteiro, float32, bits empacotados, entradas discretas e RTU sobre TCP (T2)
- S7 completo: tabela de 15 variáveis, valores arredondados e escrita do modo (T3)
- OPC-UA em conjunto: 9 variáveis assinadas, juntas num único objeto, e escrita do modo (T4)
- Painel multiprotocolo: a mesma câmara vista por 5 caminhos e o setpoint escrito por qualquer um (T5)
- Controle PI no Node-RED (lê por OPC-UA, escreve por Modbus) comparado com o PI interno no SQLite (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 15 · T4 15 · T5 15 ·
T6 25. 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\lab09-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-a"
2. Gere o LAB IoT do grupo em docker\lab09-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo a --sem-gitea --sem-microbin --sem-fuxa --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 lab09-a-nodered && (del /q "data\lab09-a\flows.json" "data\lab09-a\flows_cred.json" "data\lab09-a\.flows*.backup" 2>nul & docker compose start lab09-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-b"
2. Gere o LAB IoT do grupo em docker\lab09-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo b --sem-gitea --sem-microbin --sem-fuxa --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 lab09-b-nodered && (del /q "data\lab09-b\flows.json" "data\lab09-b\flows_cred.json" "data\lab09-b\.flows*.backup" 2>nul & docker compose start lab09-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-c"
2. Gere o LAB IoT do grupo em docker\lab09-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo c --sem-gitea --sem-microbin --sem-fuxa --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 lab09-c-nodered && (del /q "data\lab09-c\flows.json" "data\lab09-c\flows_cred.json" "data\lab09-c\.flows*.backup" 2>nul & docker compose start lab09-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-d"
2. Gere o LAB IoT do grupo em docker\lab09-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo d --sem-gitea --sem-microbin --sem-fuxa --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 lab09-d-nodered && (del /q "data\lab09-d\flows.json" "data\lab09-d\flows_cred.json" "data\lab09-d\.flows*.backup" 2>nul & docker compose start lab09-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-e"
2. Gere o LAB IoT do grupo em docker\lab09-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo e --sem-gitea --sem-microbin --sem-fuxa --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 lab09-e-nodered && (del /q "data\lab09-e\flows.json" "data\lab09-e\flows_cred.json" "data\lab09-e\.flows*.backup" 2>nul & docker compose start lab09-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-f"
2. Gere o LAB IoT do grupo em docker\lab09-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo f --sem-gitea --sem-microbin --sem-fuxa --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 lab09-f-nodered && (del /q "data\lab09-f\flows.json" "data\lab09-f\flows_cred.json" "data\lab09-f\.flows*.backup" 2>nul & docker compose start lab09-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-g"
2. Gere o LAB IoT do grupo em docker\lab09-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo g --sem-gitea --sem-microbin --sem-fuxa --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 lab09-g-nodered && (del /q "data\lab09-g\flows.json" "data\lab09-g\flows_cred.json" "data\lab09-g\.flows*.backup" 2>nul & docker compose start lab09-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-h"
2. Gere o LAB IoT do grupo em docker\lab09-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo h --sem-gitea --sem-microbin --sem-fuxa --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 lab09-h-nodered && (del /q "data\lab09-h\flows.json" "data\lab09-h\flows_cred.json" "data\lab09-h\.flows*.backup" 2>nul & docker compose start lab09-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-i"
2. Gere o LAB IoT do grupo em docker\lab09-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo i --sem-gitea --sem-microbin --sem-fuxa --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 lab09-i-nodered && (del /q "data\lab09-i\flows.json" "data\lab09-i\flows_cred.json" "data\lab09-i\.flows*.backup" 2>nul & docker compose start lab09-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-j"
2. Gere o LAB IoT do grupo em docker\lab09-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo j --sem-gitea --sem-microbin --sem-fuxa --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 lab09-j-nodered && (del /q "data\lab09-j\flows.json" "data\lab09-j\flows_cred.json" "data\lab09-j\.flows*.backup" 2>nul & docker compose start lab09-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-k"
2. Gere o LAB IoT do grupo em docker\lab09-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo k --sem-gitea --sem-microbin --sem-fuxa --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 lab09-k-nodered && (del /q "data\lab09-k\flows.json" "data\lab09-k\flows_cred.json" "data\lab09-k\.flows*.backup" 2>nul & docker compose start lab09-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-l"
2. Gere o LAB IoT do grupo em docker\lab09-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo l --sem-gitea --sem-microbin --sem-fuxa --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 lab09-l-nodered && (del /q "data\lab09-l\flows.json" "data\lab09-l\flows_cred.json" "data\lab09-l\.flows*.backup" 2>nul & docker compose start lab09-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-m"
2. Gere o LAB IoT do grupo em docker\lab09-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo m --sem-gitea --sem-microbin --sem-fuxa --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 lab09-m-nodered && (del /q "data\lab09-m\flows.json" "data\lab09-m\flows_cred.json" "data\lab09-m\.flows*.backup" 2>nul & docker compose start lab09-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab09-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab09-x"
2. Gere o LAB IoT do grupo em docker\lab09-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab09 --grupo x --sem-gitea --sem-microbin --sem-fuxa --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 lab09-x-nodered && (del /q "data\lab09-x\flows.json" "data\lab09-x\flows_cred.json" "data\lab09-x\.flows*.backup" 2>nul & docker compose start lab09-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
No Lab 08, a câmara simulada apareceu pelos quatro protocolos, com o mínimo: um nó que lê e um inject que escreve. Você viu os conceitos: registradores e escala no Modbus, bytes e tipos no S7, nós com nome e assinatura no OPC-UA.
Agora o Node-RED faz o papel de um SCADA de verdade:
- lê todo o mapa de cada protocolo, com os truques que aparecem em equipamentos reais (float em dois registradores, bits empacotados, Modbus RTU);
- junta as leituras e mostra a mesma câmara por cinco caminhos num painel;
- por fim, assume o controle: mede pelo OPC-UA, calcula um PI e atua pelo Modbus, e o SQLite registra tudo para comparar com o PI que roda dentro do "equipamento".
Objetivos
- Ler o mapa completo de um equipamento Modbus: escala, float32 em dois registradores (e a ordem das palavras), bits empacotados e entradas discretas, por TCP e por RTU.
- Montar a tabela de variáveis de um CLP S7 e tratar os
REAL. - Assinar várias variáveis OPC-UA e juntar as notificações, que chegam em lotes.
- Montar um painel com a mesma planta vista por cinco caminhos e escrever por qualquer um.
- (Integrador) Fechar uma malha de controle PI no SCADA e comparar com o PI embarcado, usando o SQLite.
Material
- O LAB IoT do
lab09-x(gerado pelogen_iot_aluno.py): mosquitto e Node-RED comnode-red-contrib-modbus,node-red-contrib-s7,node-red-contrib-opcua,node-red-node-sqlitee Dashboard 2.0, que já vêm na imagem. - O simulador
camara-sim, na pastacamara-sim/do repositório do grupo. - O fluxo do Lab 08 (
nodered/flows-lab08.json, no repositório do Lab 08). - Sem ESP32 nem Wokwi nesta aula.
- Opcional: UaExpert, para navegar no servidor OPC-UA.
O modelo tem dois estados térmicos (resistência e câmara), perdas para o ambiente (25 °C),
umidade calculada pela fórmula de Magnus (aquecer derruba a UR), ruído e falhas de leitura
do DHT22, e o ON/OFF e o PI do "firmware". Ele não simula atraso de rede, perda de pacotes
nem a segurança do OPC-UA. Com SIM_SPEED=5, um degrau de 30 → 40 °C assenta em cerca de 30 s,
em vez de 2,5 min.
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/lab09-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-a/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-a.git && cd lab09-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-b/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-b.git && cd lab09-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-c/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-c.git && cd lab09-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-d/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-d.git && cd lab09-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-e/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-e.git && cd lab09-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-f/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-f.git && cd lab09-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-g/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-g.git && cd lab09-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-h/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-h.git && cd lab09-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-i/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-i.git && cd lab09-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-j/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-j.git && cd lab09-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-k/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-k.git && cd lab09-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-l/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-l.git && cd lab09-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-m/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-m.git && cd lab09-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-x/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-x.git && cd lab09-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-p/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-p.git && cd lab09-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab09-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab09-grupo-n/commits/main/
- Acessos: ACESSO-LAB09.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/lab09-grupo-n.git && cd lab09-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab09-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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 09:
- 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 — Simulador, endereços e o fluxo do Lab 08 · 10 pts
- T2 — Modbus completo · 20 pts
- T3 — S7 completo · 15 pts
- T4 — OPC-UA em conjunto · 15 pts
- T5 — Painel multiprotocolo · 15 pts
- T6 — PI no Node-RED × PI interno · 25 pts
O repositório do grupo nasce do lab09-template, que traz uma cópia do simulador em
camara-sim/:
Estrutura de Arquivos do Projeto
- ├── 📂camara-sim
- ├── 📄camara_sim.py👈 Verificar
- ├── 📄testar_clientes.py👈 Verificar
- ├── 🚀docker-compose.yml👈 Verificar
- ├── 🚀docker-compose.lab.yml👈 Verificar
- ├── 📄.env.example👈 Verificar
- ├── 📄.env👈 Criar Aqui
- └── 📝README.md👈 Verificar
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t1-testar.txt👈 Criar Aqui
- ├── 📄t1-enderecos.txt👈 Criar Aqui
- ├── 📄t2-modbus.txt👈 Criar Aqui
- ├── 📄t3-s7.txt👈 Criar Aqui
- ├── 📄t4-opcua.txt👈 Criar Aqui
- ├── 📄t5-dashboard.png👈 Criar Aqui
- ├── 📄t6-sqlite.txt👈 Criar Aqui
- └── 📄t6-dashboard.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Troque o x pela letra do seu grupo em todos os nomes abaixo.
| O quê | Valor |
|---|---|
| Contêiner e host na rede | lab09-x-camara |
| Tópico base MQTT | elt85b/lab09/grupo-x/camara |
| Rede do stack do curso | lab09-x_labnet |
| Banco SQLite (no Node-RED) | /data/sqlite/lab09.sqlite |
| Editor do Node-RED | http://localhost/lab09-x/ |
| Dashboard | http://localhost/lab09-x/dashboard/lab09 |
Parte 1 — Simulador, endereços e o fluxo do Lab 08
1.1 Subir o simulador
Como no Lab 08, agora com os nomes do Lab 09. Com o LAB IoT do lab09-x rodando, crie o .env
na pasta camara-sim/:
- └── 📂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=lab09-a
MQTT_BASE=elt85b/lab09/grupo-a/camara
LAB_REDE=lab09-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\lab09-grupo-a\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-a-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-a
if not exist evidencias mkdir evidencias
docker exec lab09-a-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-b
MQTT_BASE=elt85b/lab09/grupo-b/camara
LAB_REDE=lab09-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\lab09-grupo-b\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-b-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-b
if not exist evidencias mkdir evidencias
docker exec lab09-b-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-c
MQTT_BASE=elt85b/lab09/grupo-c/camara
LAB_REDE=lab09-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\lab09-grupo-c\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-c-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-c
if not exist evidencias mkdir evidencias
docker exec lab09-c-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-d
MQTT_BASE=elt85b/lab09/grupo-d/camara
LAB_REDE=lab09-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\lab09-grupo-d\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-d-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-d
if not exist evidencias mkdir evidencias
docker exec lab09-d-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-e
MQTT_BASE=elt85b/lab09/grupo-e/camara
LAB_REDE=lab09-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\lab09-grupo-e\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-e-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-e
if not exist evidencias mkdir evidencias
docker exec lab09-e-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-f
MQTT_BASE=elt85b/lab09/grupo-f/camara
LAB_REDE=lab09-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\lab09-grupo-f\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-f-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-f
if not exist evidencias mkdir evidencias
docker exec lab09-f-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-g
MQTT_BASE=elt85b/lab09/grupo-g/camara
LAB_REDE=lab09-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\lab09-grupo-g\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-g-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-g
if not exist evidencias mkdir evidencias
docker exec lab09-g-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-h
MQTT_BASE=elt85b/lab09/grupo-h/camara
LAB_REDE=lab09-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\lab09-grupo-h\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-h-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-h
if not exist evidencias mkdir evidencias
docker exec lab09-h-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-i
MQTT_BASE=elt85b/lab09/grupo-i/camara
LAB_REDE=lab09-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\lab09-grupo-i\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-i-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-i
if not exist evidencias mkdir evidencias
docker exec lab09-i-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-j
MQTT_BASE=elt85b/lab09/grupo-j/camara
LAB_REDE=lab09-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\lab09-grupo-j\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-j-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-j
if not exist evidencias mkdir evidencias
docker exec lab09-j-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-k
MQTT_BASE=elt85b/lab09/grupo-k/camara
LAB_REDE=lab09-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\lab09-grupo-k\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-k-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-k
if not exist evidencias mkdir evidencias
docker exec lab09-k-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-l
MQTT_BASE=elt85b/lab09/grupo-l/camara
LAB_REDE=lab09-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\lab09-grupo-l\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-l-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-l
if not exist evidencias mkdir evidencias
docker exec lab09-l-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-m
MQTT_BASE=elt85b/lab09/grupo-m/camara
LAB_REDE=lab09-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\lab09-grupo-m\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-m-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-m
if not exist evidencias mkdir evidencias
docker exec lab09-m-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-x
MQTT_BASE=elt85b/lab09/grupo-x/camara
LAB_REDE=lab09-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\lab09-grupo-x\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-x-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-x
if not exist evidencias mkdir evidencias
docker exec lab09-x-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-p
MQTT_BASE=elt85b/lab09/grupo-p/camara
LAB_REDE=lab09-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\lab09-grupo-p\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-p-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-p
if not exist evidencias mkdir evidencias
docker exec lab09-p-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. Arquivo .env:
GRUPO=lab09-n
MQTT_BASE=elt85b/lab09/grupo-n/camara
LAB_REDE=lab09-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\lab09-grupo-n\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab09-n-camara
3. Testar e gravar:
cd /d %USERPROFILE%\ELT85BN21\lab09-grupo-n
if not exist evidencias mkdir evidencias
docker exec lab09-n-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1.2 Conferir os endereços
Os mesmos três testes do Lab 08 (seção 1.3), agora gravando a evidência:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Rede e portas:
docker network inspect lab09-a_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-a-nodered node -e "for(const[h,p]of[['lab09-a-camara',502],['lab09-a-camara',5021],['lab09-a-camara',102],['lab09-a-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-b_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-b-nodered node -e "for(const[h,p]of[['lab09-b-camara',502],['lab09-b-camara',5021],['lab09-b-camara',102],['lab09-b-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-c_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-c-nodered node -e "for(const[h,p]of[['lab09-c-camara',502],['lab09-c-camara',5021],['lab09-c-camara',102],['lab09-c-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-d_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-d-nodered node -e "for(const[h,p]of[['lab09-d-camara',502],['lab09-d-camara',5021],['lab09-d-camara',102],['lab09-d-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-e_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-e-nodered node -e "for(const[h,p]of[['lab09-e-camara',502],['lab09-e-camara',5021],['lab09-e-camara',102],['lab09-e-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-f_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-f-nodered node -e "for(const[h,p]of[['lab09-f-camara',502],['lab09-f-camara',5021],['lab09-f-camara',102],['lab09-f-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-g_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-g-nodered node -e "for(const[h,p]of[['lab09-g-camara',502],['lab09-g-camara',5021],['lab09-g-camara',102],['lab09-g-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-h_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-h-nodered node -e "for(const[h,p]of[['lab09-h-camara',502],['lab09-h-camara',5021],['lab09-h-camara',102],['lab09-h-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-i_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-i-nodered node -e "for(const[h,p]of[['lab09-i-camara',502],['lab09-i-camara',5021],['lab09-i-camara',102],['lab09-i-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-j_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-j-nodered node -e "for(const[h,p]of[['lab09-j-camara',502],['lab09-j-camara',5021],['lab09-j-camara',102],['lab09-j-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-k_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-k-nodered node -e "for(const[h,p]of[['lab09-k-camara',502],['lab09-k-camara',5021],['lab09-k-camara',102],['lab09-k-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-l_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-l-nodered node -e "for(const[h,p]of[['lab09-l-camara',502],['lab09-l-camara',5021],['lab09-l-camara',102],['lab09-l-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-m_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-m-nodered node -e "for(const[h,p]of[['lab09-m-camara',502],['lab09-m-camara',5021],['lab09-m-camara',102],['lab09-m-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-x_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-x-nodered node -e "for(const[h,p]of[['lab09-x-camara',502],['lab09-x-camara',5021],['lab09-x-camara',102],['lab09-x-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-p_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-p-nodered node -e "for(const[h,p]of[['lab09-p-camara',502],['lab09-p-camara',5021],['lab09-p-camara',102],['lab09-p-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
1. Rede e portas:
docker network inspect lab09-n_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
docker exec lab09-n-nodered node -e "for(const[h,p]of[['lab09-n-camara',502],['lab09-n-camara',5021],['lab09-n-camara',102],['lab09-n-camara',4840],['mosquitto',1883]]){const s=require('net').connect(p,h,()=>{console.log('ok '+h+':'+p);s.end()});s.on('error',e=>console.log('FALHA '+h+':'+p+' '+e.code));s.setTimeout(3000,()=>{console.log('FALHA '+h+':'+p+' timeout');s.destroy()})}" >> evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
As cinco portas (agora com a 5021, do Modbus RTU) devem sair ok.
1.3 Reaproveitar o fluxo do Lab 08
O fluxo do Lab 08 já tem um cliente para cada protocolo. Num SCADA, o endereço de cada equipamento fica num só lugar, o nó de configuração, e todos os nós de leitura e escrita apontam para ele. Para levar o fluxo para o Lab 09, basta trocar esses nós.
-
No Node-RED do Lab 09 (
http://localhost/lab09-x/): Menu ☰ → Import → selecione onodered/flows-lab08.jsondo repositório do Lab 08 → Import. -
Dê dois cliques na aba importada e troque o nome para Lab 09.
-
Na barra lateral, abra Configuration nodes (ícone de engrenagem) e troque
lab08porlab09em:Nó de configuração Campo Novo valor câmara Modbus TCP(modbus-client)Host lab09-x-camaracâmara S7 (DB1)(s7 endpoint)Address lab09-x-camaracâmara OPC-UA(OpcUa-Endpoint)Endpoint opc.tcp://lab09-x-camara:4840/ -
Troque
lab08porlab09nos tópicos do mqtt in (telemetria) e do mqtt out (cmd/setpoint). Esses ficam nos próprios nós, não num nó de configuração. -
Deploy. Os quatro debugs voltam a receber dados.
-
Exporte: Menu ☰ → Export → Current flow → Download, e salve como
nodered/flows-lab09.json. Repita a exportação no fim de cada tarefa.
Ctrl+F no editor procura por texto em todos os nós: procure lab08 e confira que não
sobrou nenhum.
- ├── 📂camara-sim
- └── 📄.env👈 Criar Aqui
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-testar.txt👈 Criar Aqui
- └── 📄t1-enderecos.txt👈 Criar Aqui
git conferir camara-sim/.env nodered/flows-lab09.json evidencias/t1-testar.txt evidencias/t1-enderecos.txt
Simulador, endereços e o fluxo do Lab 08
git conferir camara-sim/.env nodered/flows-lab09.json evidencias/t1-testar.txt evidencias/t1-enderecos.txt
git add camara-sim/.env nodered/flows-lab09.json evidencias/t1-testar.txt evidencias/t1-enderecos.txt && git commit -m "T1: Simulador, endereços e o fluxo do Lab 08" && 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 — Modbus completo
2.1 O mapa inteiro
No Lab 08, você leu os IR 0 a 4. Este é o mapa completo da câmara (unit 1, endereços base 0):
| Tabela (código de função) | Acesso | End. | Variável |
|---|---|---|---|
| Coils (FC1 lê · FC5/FC15 escreve) | R/W bit | 0 / 1 | habilitado / falha_dht (simulação) |
| Discrete inputs (FC2) | R bit | 0–4 | LED verde, amarelo, vermelho, dht_ok, alarme ativo |
| Holding registers (FC3 lê · FC6/FC16 escreve) | R/W 16 bits | 0 / 1 / 2 | habilitado / modo (0 MANUAL, 1 ON/OFF, 2 PI) / fonte_sp |
| 3 | setpoint × 10 (350 = 35,0 °C) | ||
| 4 / 5 | aquecedor_cmd / ventilador_cmd (%), valem no modo MANUAL | ||
| Input registers (FC4) | R 16 bits | 0 / 1 / 2 | temperatura × 10 / umidade × 10 / setpoint efetivo × 10 |
| 3 / 4 / 5 | aquecedor / ventilador aplicados (%) / pot_raw | ||
| 6 / 7 | estado (0 DESLIGADO … 4 ALARME) / alarme (bits) | ||
| 8 | LEDs: bit0 verde, bit1 amarelo, bit2 vermelho | ||
| 10 | heartbeat (conta a cada ciclo do "firmware") | ||
| 12–13 | temperatura em float32 (palavra alta primeiro, ABCD) | ||
| 14–15 | umidade em float32 (ABCD) |
Além da escala (Lab 08), dois truques que aparecem em quase todo equipamento real:
- Float32 em dois registradores: o mesmo valor aparece como
floatIEEE 754 ocupando dois registradores. A ordem das palavras (ABCD, CDAB…) muda de fabricante para fabricante, e errar a ordem dá números absurdos. - Bits empacotados: vários sinais booleanos dentro de um registrador (o IR8 dos LEDs).
2.2 Dois clientes: TCP e RTU sobre TCP
O mesmo escravo responde em duas portas. A 502 usa Modbus TCP (cabeçalho MBAP, sem CRC). A 5021 usa o quadro RTU (endereço + função + dados + CRC-16), o mesmo da RS-485, só que transportado por TCP, como faz um conversor serial-Ethernet. Crie um segundo modbus-client:
| Campo | câmara Modbus TCP (do Lab 08) | câmara Modbus RTU/TCP (novo) |
|---|---|---|
| Type | TCP | TCP |
| Host | lab09-x-camara | lab09-x-camara |
| Port | 502 | 5021 |
| TCP Type | DEFAULT | TELNET |
| Unit-Id | 1 | 1 |
No node-red-contrib-modbus, o tipo que envia quadros RTU crus pelo socket se chama
TELNET. O "TCP-RTU-BUFFERED", apesar do nome, envia cabeçalho Modbus TCP, e o simulador na
5021 não responde (o nó fica em timeout).
2.3 Ler e decodificar tudo
- Troque o modbus-read do Lab 08 para Address
0, Quantity18, Topicmodbus_tcp, e o nome para "FC4 IR 0..17". - Um segundo modbus-read, pelo cliente RTU, a cada
5 s, Topicmodbus_rtu. - modbus-read "FC2 DI 0..4": FC 2: Read Discrete Inputs, Address
0, Quantity5, direto num debug "LEDs/alarme (bits)". - A function "÷10 e nomes" do Lab 08 vira esta:
// Input registers 0..17 da câmara -> objeto com nomes e unidades
const r = msg.payload;
if (!Array.isArray(r) || r.length < 18) return null;
const s16 = (v) => (v > 0x7fff ? v - 0x10000 : v); // int16 com sinal
const f32 = (i) => {
// float32 big-endian (ABCD)
const b = Buffer.alloc(4);
b.writeUInt16BE(r[i], 0);
b.writeUInt16BE(r[i + 1], 2);
return b.readFloatBE(0);
};
const ESTADOS = ["DESLIGADO", "AQUECENDO", "RESFRIANDO", "ESTAVEL", "ALARME"];
msg.payload = {
temp_x10: s16(r[0]) / 10, // IR0: °C x 10
temp: Number(f32(12).toFixed(2)), // IR12-13: float32
umid: Number(f32(14).toFixed(1)), // IR14-15
sp_efetivo: s16(r[2]) / 10, // IR2
aquecedor_pwm: r[3],
ventilador_pwm: r[4],
pot_raw: r[5],
estado: r[6],
estado_txt: ESTADOS[r[6]] ?? "?",
alarme: r[7],
leds: {
verde: r[8] & 1,
amarelo: (r[8] >> 1) & 1,
vermelho: (r[8] >> 2) & 1,
},
heartbeat: r[10],
};
return msg;
Ligue a function a um debug "Modbus TCP" (status: payload.temp). As leituras TCP e RTU
caem no mesmo debug: o msg.topic (modbus_tcp ou modbus_rtu) diz de onde veio cada uma.
Modbus TCP: { temp_x10: 34.8, temp: 34.8, umid: 37.8, sp_efetivo: 35, aquecedor_pwm: 0,
ventilador_pwm: 20, pot_raw: 1758, estado: 3, estado_txt: 'ESTAVEL', alarme: 0,
leds: { verde: 1, amarelo: 0, vermelho: 0 }, heartbeat: 152 }
LEDs/alarme (bits): [ true, false, false, true, false, false, false, false ]
As entradas discretas chegam como 8 booleanos, embora você tenha pedido 5: o Modbus
transporta bits em bytes inteiros. Só os 5 primeiros têm significado (verde, amarelo,
vermelho, dht_ok, alarme).
P1: (a) com 36,2 °C, os IR12–13 valem 0x4210 e 0xCCCD. Se o seu cliente lesse na
ordem CDAB (palavra baixa primeiro), que número apareceria? Troque r[i] e r[i + 1] na
f32 e confira. Que tipo de valor denuncia uma ordem de palavras errada? (b) O IR8 vale 6.
Quais LEDs estão acesos? Se o equipamento já entrega os LEDs nos DI 0–2, por que também os
empacota no IR8?
Evidência: em evidencias/t2-modbus.txt, um objeto do debug "Modbus TCP" com topic
modbus_tcp, outro com modbus_rtu, um array do debug de LEDs e as linhas [cmd] do log
(docker logs lab09-x-camara 2>&1 | findstr /l /c:"[cmd]") depois de usar os injects do Lab 08.
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t2-modbus.txt👈 Criar Aqui
git conferir nodered/flows-lab09.json evidencias/t2-modbus.txt
Modbus completo
git conferir nodered/flows-lab09.json evidencias/t2-modbus.txt
git add nodered/flows-lab09.json evidencias/t2-modbus.txt && git commit -m "T2: Modbus completo" && 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 — S7 completo
3.1 A tabela de variáveis inteira
| Endereço nodes7 | Bytes | Variável | Acesso |
|---|---|---|---|
DB1,X0.0 | 0.0 | habilitado | R/W |
DB1,X0.1 | 0.1 | fonte_sp (0 remoto, 1 potenciômetro) | R/W |
DB1,INT2 | 2–3 | modo | R/W |
DB1,REAL4 | 4–7 | setpoint (°C) | R/W |
DB1,REAL8 | 8–11 | aquecedor_cmd (%) | R/W |
DB1,REAL12 | 12–15 | ventilador_cmd (%) | R/W |
DB1,REAL20 | 20–23 | temp (°C) | R |
DB1,REAL24 | 24–27 | umid (%) | R |
DB1,REAL28 | 28–31 | sp_efetivo (°C) | R |
DB1,REAL32 / REAL36 | 32–39 | aquecedor_pwm / ventilador_pwm (%) | R |
DB1,INT40 / INT42 | 40–43 | estado / alarme | R |
DB1,X44.0 … X44.2 | 44 | led_verde, led_amarelo, led_vermelho | R |
DB1,DINT48 | 48–51 | heartbeat | R |
O DB1 do simulador é sem acesso otimizado: os endereços são fixos, como num S7-300 ou num S7-1200 com Optimized block access desligado. Num S7-1200/1500 real, isso e o PUT/GET precisam ser liberados no TIA Portal.
3.2 Ler, arredondar e escrever o modo
No s7 endpoint "câmara S7 (DB1)", complete a tabela com as 15 variáveis (o nome à direita, o endereço à esquerda), com os nomes exatamente como na coluna "Variável".
Entre o s7 in e o debug, uma function que arredonda os REAL (no Lab 08 eles chegavam como
36.400001525878906) e marca a origem:
// "s7 in" (todas as variáveis) -> números arredondados
const p = msg.payload;
const r = (v) => Math.round(v * 100) / 100;
msg.payload = Object.assign({}, p, {
temp: r(p.temp),
umid: r(p.umid),
setpoint: r(p.setpoint),
sp_efetivo: r(p.sp_efetivo),
aquecedor_pwm: r(p.aquecedor_pwm),
ventilador_pwm: r(p.ventilador_pwm),
});
msg.topic = "s7";
return msg;
E um s7 out Variable modo, com injects 1 (ON/OFF) e 2 (PI). Escreva 2 e confira,
no debug "Modbus TCP", que o comportamento do aquecedor muda: o ON/OFF liga e desliga a 100 %,
o PI modula.
{ habilitado: true, fonte_sp: false, modo: 1, setpoint: 35, temp: 34.9, umid: 37.9, sp_efetivo: 35,
aquecedor_pwm: 0, ventilador_pwm: 20, estado: 3, alarme: 0, led_verde: true, led_amarelo: false,
led_vermelho: false, heartbeat: 149 }
P2: a mesma informação dos LEDs aparece de três formas: os DI 0–2 do Modbus (3 bits), o
IR8 (um registrador com 3 bits dentro) e os DB1,X44.0…X44.2 do S7 (3 bits do mesmo byte).
Quantas requisições cada cliente precisa para ler os 3 LEDs e a temperatura? Por que o
s7 in "All variables" lê 15 variáveis sem fazer 15 requisições?
Evidência: em evidencias/t3-s7.txt, um objeto do debug "S7" e as linhas [cmd] s7: do
log do simulador.
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t3-s7.txt👈 Criar Aqui
git conferir nodered/flows-lab09.json evidencias/t3-s7.txt
S7 completo
git conferir nodered/flows-lab09.json evidencias/t3-s7.txt
git add nodered/flows-lab09.json evidencias/t3-s7.txt && git commit -m "T3: S7 completo" && 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 — OPC-UA em conjunto
No Lab 08, você assinou temp e setpoint, cada um com um inject. Para um painel, é preciso
assinar várias variáveis e trabalhar com elas como um objeto.
Medicoes/ temp · umid · pot_raw ns=2;s=Camara.temp ...
Atuadores/ aquecedor_pwm · ventilador_pwm · *_duty
Estado/ estado · estado_txt · alarme · led_* · heartbeat · uptime · oled
Comandos/ habilitado · modo · fonte_sp · setpoint · aquecedor_cmd · ventilador_cmd (graváveis)
Simulacao/ pot_raw_sim · falha_dht (graváveis)
4.1 Assinar nove variáveis
Troque os dois injects do Lab 08 por um inject "assinar" (once, 4 s) e uma function que
gera uma mensagem por variável, cada uma com o NodeId no topic:
// Uma mensagem por variável a assinar: msg.topic = NodeId, msg.datatype = tipo OPC-UA
const vars = {
temp: "Double",
umid: "Double",
setpoint: "Double",
sp_efetivo: "Double",
aquecedor_pwm: "Double",
ventilador_pwm: "Double",
modo: "Int32",
estado_txt: "String",
heartbeat: "Int32",
};
return [
Object.entries(vars).map(([n, t]) => ({
topic: `ns=2;s=Camara.${n}`,
datatype: t,
payload: "",
})),
];
Retornar [ [msg1, msg2, …] ] (um array dentro de outro) faz a function enviar as nove
mensagens em sequência pela mesma saída.
4.2 Juntar as notificações
Cada mudança chega numa mensagem separada (o NodeId no topic, o valor no payload). Entre o
OpcUa-Client e o debug, esta function guarda o último valor de cada variável e emite um
objeto:
// Cada variável assinada chega numa mensagem separada (msg.topic = NodeId).
// O servidor entrega as mudanças em LOTES (a cada ~2 s): guarda o último valor de
// cada variável e emite UM conjunto 200 ms depois da última mensagem do lote.
const nome = String(msg.topic).split("Camara.")[1];
if (!nome) return null; // ex.: a mensagem "subscriptionId"
const v =
msg.payload && msg.payload.value !== undefined
? msg.payload.value.value // versões antigas do node-red-contrib-opcua
: msg.payload;
const d = context.get("d") || {};
d[nome] = v;
context.set("d", d);
if (Object.keys(d).length < 9) return null; // ainda faltam variáveis
clearTimeout(context.get("tmr"));
context.set(
"tmr",
setTimeout(() => {
const r = (x) => Math.round(x * 100) / 100;
node.send({
topic: "opcua",
payload: Object.assign({}, d, {
temp: r(d.temp),
umid: r(d.umid),
aquecedor_pwm: r(d.aquecedor_pwm),
ventilador_pwm: r(d.ventilador_pwm),
}),
});
}, 200),
);
return null;
{ temp: 34.9, umid: 37.9, setpoint: 35, sp_efetivo: 35, aquecedor_pwm: 0, ventilador_pwm: 20,
modo: 1, estado_txt: 'ESTAVEL', heartbeat: 149 }
O servidor guarda todas as mudanças de cada item monitorado e as entrega juntas, a cada
2 s. O heartbeat muda a cada ciclo do simulador: chegam 4 ou 5 mensagens dele no mesmo
milissegundo. Emitir a cada mensagem geraria 4 ou 5 conjuntos repetidos a cada 2 s (e 4 ou
5 linhas por ciclo no SQLite da T6). O setTimeout reiniciado a cada mensagem (debounce)
espera o lote terminar e emite um conjunto, com os valores mais recentes.
4.3 Escrever o modo
Um segundo OpcUa-Item no OpcUa-Client "escreve" do Lab 08: Item ns=2;s=Camara.modo,
Type Int32, com um inject 2. O tipo tem de ser o do nó: Double para o setpoint,
Int32 para o modo.
P3: (a) sem o setTimeout, quantos objetos o "junta variáveis" emitiria a cada 2 s? Tire o
debounce (emita a cada mensagem) e conte no debug. (b) No Lab 08 você contou ~100 mensagens
de temp por minuto com SIM_SPEED=5. Um SCADA com 500 variáveis, das quais 480 quase nunca
mudam, gera mais ou menos tráfego com assinatura do que com varredura a cada 2 s?
Evidência: em evidencias/t4-opcua.txt, um objeto do debug "OPC-UA" e as linhas
[cmd] opcua: do log do simulador (setpoint e modo).
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t4-opcua.txt👈 Criar Aqui
git conferir nodered/flows-lab09.json evidencias/t4-opcua.txt
OPC-UA em conjunto
git conferir nodered/flows-lab09.json evidencias/t4-opcua.txt
git add nodered/flows-lab09.json evidencias/t4-opcua.txt && git commit -m "T4: OPC-UA em conjunto" && 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 — Painel multiprotocolo
Agora o dashboard mostra a mesma câmara vista por cinco caminhos e permite escrever o setpoint por qualquer um deles.
5.1 Tabela comparativa
Ligue as saídas de "decodifica IR", "arredonda" e "junta variáveis" a uma nova function. Para o
MQTT, ligue o mqtt in da telemetria do Lab 08 a uma function que só faz
msg.topic = "mqtt"; return msg;, e dela à mesma function.
// Guarda a última leitura de cada caminho e monta a tabela comparativa
const fonte = msg.topic; // modbus_tcp | modbus_rtu | s7 | opcua | mqtt
const p = msg.payload;
const ult = flow.get("ultimas") || {};
ult[fonte] = {
t: p.temp,
sp: p.sp_efetivo ?? p.setpoint,
aq: p.aquecedor_pwm,
estado:
p.estado_txt ??
["DESLIGADO", "AQUECENDO", "RESFRIANDO", "ESTAVEL", "ALARME"][p.estado] ??
"?",
em: Date.now(),
};
flow.set("ultimas", ult);
const NOMES = {
modbus_tcp: "Modbus TCP (FC4)",
modbus_rtu: "Modbus RTU/TCP",
s7: "S7 (DB1)",
opcua: "OPC-UA (assinatura)",
mqtt: "MQTT (telemetria)",
};
const agora = Date.now();
msg.payload = Object.keys(NOMES)
.filter((k) => ult[k])
.map((k) => ({
caminho: NOMES[k],
"T (°C)": ult[k].t?.toFixed(2),
"SP (°C)": ult[k].sp?.toFixed(1),
"aquecedor (%)": Math.round(ult[k].aq),
estado: ult[k].estado,
"idade (s)": ((agora - ult[k].em) / 1000).toFixed(1),
}));
return msg;
No Dashboard 2.0, crie a página Lab 09 (path /lab09) e os grupos Mesma câmara, quatro
protocolos (largura 8), Escrever o setpoint (4), Controle PI no Node-RED (4) e
Temperatura × setpoint (8). Ligue a function a um ui-table (colunas automáticas, Max
rows 6) no primeiro grupo. O painel abre em http://localhost/lab09-x/dashboard/lab09.
5.2 Escrever por qualquer protocolo
- ui-dropdown "Escrever por": opções
modbus(rótulo "Modbus (FC6 HR3)"),s7,opcuaemqtt; Topicvia. - ui-slider "Setpoint (°C)": 20 a 55, passo 0,5, envia ao soltar, Topic
sp. - Os dois entram na mesma function de 4 saídas:
// Encaminha o setpoint para o protocolo escolhido no dropdown
if (msg.topic === "via") {
context.set("via", msg.payload);
node.status({ text: "via " + msg.payload });
return null;
}
const via = context.get("via") || "modbus";
const sp = Number(msg.payload);
flow.set("escrita", { via, sp, em: Date.now() });
node.status({ fill: "blue", shape: "dot", text: `SP ${sp} °C via ${via}` });
const out = [null, null, null, null];
out[["modbus", "s7", "opcua", "mqtt"].indexOf(via)] = { payload: sp };
return out;
| Saída | Liga em |
|---|---|
| 1 | function "°C → HR3 (×10)" do Lab 08 (que já leva ao FC6 HR3) |
| 2 | s7 out setpoint do Lab 08 |
| 3 | OpcUa-Item Camara.setpoint do Lab 08 |
| 4 | mqtt out elt85b/lab09/grupo-x/camara/cmd/setpoint do Lab 08 |
Escolha cada protocolo, mova o slider e veja as cinco linhas convergirem para o novo SP. A coluna idade mostra há quanto tempo cada caminho foi atualizado: o RTU, lido a cada 5 s, é o mais "velho".
Evidência: a captura do dashboard com as cinco linhas em evidencias/t5-dashboard.png e o
fluxo exportado.
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t5-dashboard.png👈 Criar Aqui
git conferir nodered/flows-lab09.json evidencias/t5-dashboard.png
Painel multiprotocolo
git conferir nodered/flows-lab09.json evidencias/t5-dashboard.png
git add nodered/flows-lab09.json evidencias/t5-dashboard.png && git commit -m "T5: Painel multiprotocolo" && 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 — PI no Node-RED × PI interno
Até aqui, quem controla a temperatura é o "firmware" da câmara (modo 1 ON/OFF ou modo 2 PI). Agora o SCADA assume o controle: a câmara vai para o modo 0 MANUAL, em que obedece aos registradores HR4 (aquecedor) e HR5 (ventilador), e o Node-RED calcula esses valores com um PI. A medição vem pelo OPC-UA e a atuação vai pelo Modbus, como num sistema real em que o SCADA conversa com equipamentos de fabricantes diferentes.
O controlador é discreto, executado a cada conjunto do OPC-UA (~2 s):
e = SP − T (°C)
I = I + Ki · e · dt só se a saída não estiver saturada no sentido do erro
u = Kp · e + I → aquecedor = u limitado a 0…100 %
ventilador = 20 + 30 · (−e − 0,5) limitado a 20…100 % (20 % = circulação)
Requisitos
-
Ativação. Um ui-switch "PI no Node-RED (modo MANUAL)" ligado a uma function de 2 saídas:
- ligado: guarda
flow.pi_ativo = truee escreve[1, 0]em HR0..1 (habilitado, modo MANUAL) com FC16; - desligado: escreve
2no HR1 com FC6 (volta ao PI interno).
function: ativa / desativa// Liga/desliga o controle externo.// Ligar: HR0..1 = [1, 0] -> habilitado, modo MANUAL (a câmara obedece HR4/HR5)// Desligar: HR1 = 2 -> volta ao PI internoflow.set("pi_ativo", msg.payload === true);node.status({fill: msg.payload ? "green" : "grey",shape: "ring",text: msg.payload ? "externo" : "interno",});return msg.payload ? [{ payload: [1, 0] }, null] : [null, { payload: 2 }]; - ligado: guarda
-
Controlador. Function "PI" alimentada pelo "junta variáveis" da T4, com 2 saídas:
[aquecedor, ventilador]para um modbus-write FC16 em HR4, quantidade 2, e um objeto de diagnóstico para um debug. Ela só atua compi_ativoemodo === 0. Fora disso, zera o integrador.function: PI (Kp=12, Ki=0,4)// Controlador PI EXTERNO. Entrada: conjunto do OPC-UA (a cada ~2 s).// Só atua quando o controle externo está ativo e a câmara está em modo MANUAL (0).const p = msg.payload;const ativo = flow.get("pi_ativo") === true;if (!ativo || p.modo !== 0) {context.set("I", 0);context.set("t0", null);return [null, null];}const KP = 12,KI = 0.4; // %/°C e %/(°C·s) <-- ajuste aquiconst agora = Date.now() / 1000;const t0 = context.get("t0");const dt = t0 ? Math.min(agora - t0, 10) : 0;context.set("t0", agora);const e = p.setpoint - p.temp; // erro (°C)let I = context.get("I") || 0;let u = KP * e + I;// anti-windup: só integra se não estiver saturado no sentido do erroif ((u < 100 || e < 0) && (u > 0 || e > 0))I = Math.min(100, Math.max(0, I + KI * e * dt));context.set("I", I);const aq = Math.round(Math.min(100, Math.max(0, KP * e + I)));const ve = Math.round(Math.min(100, Math.max(20, 20 + 30 * (-e - 0.5)))); // 20 % = circulaçãonode.status({fill: "green",shape: "dot",text: `e=${e.toFixed(2)} I=${I.toFixed(1)} aq=${aq}% ve=${ve}%`,});return [{ payload: [aq, ve] }, { payload: { e, I, aq, ve } }];FC16 no modbus-writePara escrever dois registradores, o FC do modbus-write tem de ser FC 16: Preset Multiple Registers (no fluxo exportado,
"dataType": "MHoldingRegisters") e o payload, um array. Com FC 6 e quantidade 2, o nó escreve só o primeiro valor e não dá erro: o ventilador nunca muda e o modo nunca vai a 0. -
Registro. Tabela
controleno/data/sqlite/lab09.sqlite: um nó de configuração sqlitedb com esse caminho (modo Read-Write-Create), um nó sqlite "consultas" em Via msg.topic e um inject once (0,5 s) com oCREATEno topic. Uma linha por conjunto do OPC-UA:msg.topic do inject 'Criar tabela'CREATE TABLE IF NOT EXISTS controle (id INTEGER PRIMARY KEY AUTOINCREMENT,recebido_em TEXT DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now', 'localtime')),modo INTEGER, -- 0 MANUAL (PI no Node-RED), 1 ON/OFF, 2 PI internot REAL, -- °C (OPC-UA)sp REAL, -- setpoint efetivo (°C)aq REAL, -- % aquecedor aplicadove REAL -- % ventilador aplicado);function: monta parâmetros// Cada conjunto do OPC-UA -> uma linha (com parâmetros)const p = msg.payload;if (typeof p.temp !== "number" || typeof p.sp_efetivo !== "number")return null;msg.params = {$modo: p.modo,$t: p.temp,$sp: p.sp_efetivo,$aq: p.aquecedor_pwm,$ve: p.ventilador_pwm,};return msg;sqlite 'INSERT' (Prepared Statement)INSERT INTO controle (modo, t, sp, aq, ve) VALUES ($modo, $t, $sp, $aq, $ve); -
Gráfico. O mesmo conjunto vira 3 pontos num ui-chart "Temperatura × setpoint" (séries
T (°C),SP (°C)eaquecedor (%/2), X = keyts, Y = keyvalor, série = keyserie, 15 minutos):function: pontos// Conjunto do OPC-UA -> pontos do gráficoconst p = msg.payload,ts = Date.now();return {payload: [{ ts, serie: "T (°C)", valor: p.temp },{ ts, serie: "SP (°C)", valor: p.sp_efetivo },{ ts, serie: "aquecedor (%/2)", valor: p.aquecedor_pwm / 2 },],}; -
Experimento (com
SIM_SPEED=5):- inject "Apagar tudo" (
DELETE FROM controle;no topic); - PI interno: inject modo PI (2) (do S7 ou do OPC-UA; a câmara começa em ON/OFF), SP 30 °C, espere ~1 min; SP 40 °C, espere ~1 min;
- PI no Node-RED: SP 30 °C, ligue o switch, espere ~1 min; SP 40 °C, espere ~1 min;
- rode as duas consultas abaixo (cada uma num inject com a consulta no topic, ligado ao nó "consultas" e a um debug "resultado").
Comparar controladores (10 min)SELECT CASE modo WHEN 0 THEN 'PI Node-RED' WHEN 1 THEN 'ON/OFF interno'WHEN 2 THEN 'PI interno' END AS controlador,COUNT(*) AS n,ROUND(AVG(ABS(sp - t)), 2) AS erro_medio,ROUND(100.0 * SUM(ABS(sp - t) > 0.5) / COUNT(*), 0) AS pct_fora_banda,ROUND(AVG(aq), 1) AS aq_medioFROM controleWHERE recebido_em >= datetime('now', 'localtime', '-10 minutes')GROUP BY modo;Último degrau (pico e tempo)-- Último degrau de SUBIDA de cada controlador: sobressinal e tempo até a banda de 0,5 °CWITH m AS (SELECT id, recebido_em, modo, t, sp, LAG(sp) OVER (ORDER BY id) AS sp_ant FROM controle),d AS (SELECT modo, MAX(id) AS id0 FROM m WHERE sp > sp_ant GROUP BY modo),j AS (SELECT m.*, (SELECT recebido_em FROM m AS a WHERE a.id = d.id0) AS t0FROM m JOIN d ON m.modo = d.modo AND m.id >= d.id0WHERE m.sp = (SELECT sp FROM m AS b WHERE b.id = d.id0))SELECT CASE modo WHEN 0 THEN 'PI Node-RED' WHEN 1 THEN 'ON/OFF interno'WHEN 2 THEN 'PI interno' END AS controlador,MAX(sp) AS sp, COUNT(*) AS n,ROUND(MAX(t) - MAX(sp), 2) AS sobressinal,ROUND((julianday(MIN(CASE WHEN t >= sp - 0.5 THEN recebido_em END))- julianday(MIN(t0))) * 86400, 0) AS s_ate_bandaFROM j GROUP BY modo;A segunda consulta usa
LAG()para achar a linha em que o SP subiu. A partir dela, mede o pico acima do SP e quanto tempo a temperatura levou para chegar a 0,5 °C dele. - inject "Apagar tudo" (
-
Evidências:
evidencias/t6-sqlite.txt: a saída das duas consultas;evidencias/t6-dashboard.png: o gráfico com os dois degraus (interno e externo);- o fluxo exportado de novo em
nodered/flows-lab09.json; - no
README.md, as respostas de P1 a P4.
Resultado de referência (simulador com SIM_SPEED=5; os seus números vão variar um pouco
por causa do ruído):
controlador n erro_medio pct_fora_banda aq_medio
PI Node-RED 60 2.01 62 32.4
ON/OFF interno 1 0.6 100 100
PI interno 61 1.46 39 33.7
controlador sp n sobressinal s_ate_banda
PI Node-RED 40.0 31 -0.2 26
PI interno 40.0 30 0.0 22
Os dois PIs chegam ao SP sem sobressinal (o negativo quer dizer que o pico ficou abaixo do SP).
O externo é um pouco mais lento: ele só corrige a cada ~2 s, e cada correção atravessa
dois protocolos (OPC-UA na ida, Modbus na volta), enquanto o interno roda a cada ciclo do
"firmware". O erro_medio alto vem dos degraus: logo depois de cada mudança, o erro é de 10 °C.
A linha "ON/OFF interno" é a leitura de antes do "modo PI (2)".
P4: com o PI externo ligado e o aquecedor a 80 %, o contêiner do Node-RED cai. O que
acontece com o HR4 e com a temperatura da câmara? Alguém desliga o aquecedor? A proteção de
sobretemperatura do simulador (60 °C, veja o camara-sim/README.md) chega a atuar? Teste:
docker stop lab09-x-nodered, acompanhe a temperatura com o testar_clientes.py ou o UaExpert
por alguns minutos e depois docker start lab09-x-nodered. Proponha uma forma de evitar o
problema, por exemplo um watchdog no equipamento que volta ao modo 2 se o HR4 não for reescrito
em 10 s, e diga por que ela precisa ficar no equipamento e não no Node-RED.
- ├── 📂nodered
- └── 🔧flows-lab09.json👈 Edite Aqui
- ├── 📂evidencias
- ├── 📄t6-sqlite.txt👈 Criar Aqui
- └── 📄t6-dashboard.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir nodered/flows-lab09.json evidencias/t6-sqlite.txt evidencias/t6-dashboard.png README.md
PI no Node-RED × PI interno
git conferir nodered/flows-lab09.json evidencias/t6-sqlite.txt evidencias/t6-dashboard.png README.md
git add nodered/flows-lab09.json evidencias/t6-sqlite.txt evidencias/t6-dashboard.png README.md && git commit -m "T6: PI no Node-RED × PI interno" && 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 |
|---|---|
| Nós Modbus com "propriedades inválidas: Server" | no modbus-client, o Serial port não pode ficar vazio, mesmo com Type TCP: mude para Serial, preencha /dev/ttyUSB, volte para TCP |
| RTU em timeout | o TCP Type do cliente da porta 5021 é TELNET |
| Temperatura absurda (±10⁸ ou 10⁻³⁸) | ordem das palavras do float32 trocada (P1) |
| Ventilador não muda no PI externo | o modbus-write de HR4..5 está em FC6; use FC16 com payload array |
BadTypeMismatch | o Type do OpcUa-Item tem de ser o do nó (Double no setpoint, Int32 no modo) |
| Linhas repetidas no SQLite | falta o debounce no "junta variáveis" (P3) |
SQLITE_CANTOPEN | o caminho é /data/sqlite/lab09.sqlite (pasta sqlite dentro do /data do Node-RED) |
| O dashboard não abre | http://localhost/lab09-x/dashboard/lab09; a página precisa do path /lab09 |
Sobrou lab08 em algum nó | Ctrl+F no editor procura em todos os nós |
Logout do seu ambiente dev, git e gh
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.