Laboratório 08
Checklist — protocolos industriais: Modbus, S7 e OPC-UA (conceitos iniciais)
-
camara-simrodando na rede do stack do curso, com otestar_clientes.pypassando (T1) - Modbus TCP no Node-RED: leitura dos registradores com escala e escrita do setpoint e da bobina (T2)
- S7: leitura do DB1 por endereço e escrita do setpoint (T3)
- OPC-UA: assinatura de dois nós e escrita do setpoint por NodeId (T4)
- Uma planta, quatro portas: o setpoint escrito por cada protocolo e lido por todos, e a contagem de mensagens (T5)
- 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…T5 = 100 pts (esta aula não tem desafios): T1 15 · T2 25 · T3 20 · T4 20 · T5 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\lab08-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-a"
2. Gere o LAB IoT do grupo em docker\lab08-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-a-nodered && (del /q "data\lab08-a\flows.json" "data\lab08-a\flows_cred.json" "data\lab08-a\.flows*.backup" 2>nul & docker compose start lab08-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-b"
2. Gere o LAB IoT do grupo em docker\lab08-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-b-nodered && (del /q "data\lab08-b\flows.json" "data\lab08-b\flows_cred.json" "data\lab08-b\.flows*.backup" 2>nul & docker compose start lab08-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-c"
2. Gere o LAB IoT do grupo em docker\lab08-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-c-nodered && (del /q "data\lab08-c\flows.json" "data\lab08-c\flows_cred.json" "data\lab08-c\.flows*.backup" 2>nul & docker compose start lab08-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-d"
2. Gere o LAB IoT do grupo em docker\lab08-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-d-nodered && (del /q "data\lab08-d\flows.json" "data\lab08-d\flows_cred.json" "data\lab08-d\.flows*.backup" 2>nul & docker compose start lab08-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-e"
2. Gere o LAB IoT do grupo em docker\lab08-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-e-nodered && (del /q "data\lab08-e\flows.json" "data\lab08-e\flows_cred.json" "data\lab08-e\.flows*.backup" 2>nul & docker compose start lab08-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-f"
2. Gere o LAB IoT do grupo em docker\lab08-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-f-nodered && (del /q "data\lab08-f\flows.json" "data\lab08-f\flows_cred.json" "data\lab08-f\.flows*.backup" 2>nul & docker compose start lab08-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-g"
2. Gere o LAB IoT do grupo em docker\lab08-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-g-nodered && (del /q "data\lab08-g\flows.json" "data\lab08-g\flows_cred.json" "data\lab08-g\.flows*.backup" 2>nul & docker compose start lab08-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-h"
2. Gere o LAB IoT do grupo em docker\lab08-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-h-nodered && (del /q "data\lab08-h\flows.json" "data\lab08-h\flows_cred.json" "data\lab08-h\.flows*.backup" 2>nul & docker compose start lab08-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-i"
2. Gere o LAB IoT do grupo em docker\lab08-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-i-nodered && (del /q "data\lab08-i\flows.json" "data\lab08-i\flows_cred.json" "data\lab08-i\.flows*.backup" 2>nul & docker compose start lab08-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-j"
2. Gere o LAB IoT do grupo em docker\lab08-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-j-nodered && (del /q "data\lab08-j\flows.json" "data\lab08-j\flows_cred.json" "data\lab08-j\.flows*.backup" 2>nul & docker compose start lab08-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-k"
2. Gere o LAB IoT do grupo em docker\lab08-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-k-nodered && (del /q "data\lab08-k\flows.json" "data\lab08-k\flows_cred.json" "data\lab08-k\.flows*.backup" 2>nul & docker compose start lab08-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-l"
2. Gere o LAB IoT do grupo em docker\lab08-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-l-nodered && (del /q "data\lab08-l\flows.json" "data\lab08-l\flows_cred.json" "data\lab08-l\.flows*.backup" 2>nul & docker compose start lab08-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-m"
2. Gere o LAB IoT do grupo em docker\lab08-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-m-nodered && (del /q "data\lab08-m\flows.json" "data\lab08-m\flows_cred.json" "data\lab08-m\.flows*.backup" 2>nul & docker compose start lab08-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab08-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab08-x"
2. Gere o LAB IoT do grupo em docker\lab08-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab08 --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 lab08-x-nodered && (del /q "data\lab08-x\flows.json" "data\lab08-x\flows_cred.json" "data\lab08-x\.flows*.backup" 2>nul & docker compose start lab08-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Nos Labs 05 a 07, o ESP32 montou uma câmara climática (DHT22, OLED, potenciômetro, aquecedor e ventilador) que falava MQTT, o protocolo típico de IoT.
Na indústria, quem conversa com o chão de fábrica são CLPs, IHMs e SCADAs, e eles
falam outros protocolos: Modbus, S7 (Siemens) e OPC-UA. Nesta aula, a câmara vira
uma "máquina" industrial: o camara-sim é a mesma câmara, simulada num contêiner, que
expõe a mesma planta pelos quatro protocolos ao mesmo tempo.
O objetivo é entender como cada protocolo organiza os dados e como o dado chega ao cliente. Por isso, o Node-RED faz só o mínimo: um nó que lê e mostra no debug, e um inject que escreve. Sem dashboard, sem banco, sem controle.
Os quatro protocolos em uma tabela
Guarde esta tabela: cada parte da aula preenche uma linha dela na prática.
| Modbus TCP | S7 | OPC-UA | MQTT | |
|---|---|---|---|---|
| Origem | Modicon, 1979 (serial); aberto | Siemens; proprietário | OPC Foundation; aberto (IEC 62541) | IBM, 1999; aberto (OASIS) |
| Como o dado é endereçado | número do registrador (IR0, HR3) | bloco + byte (DB1,REAL20) | nó com nome (ns=2;s=Camara.temp) | tópico (.../telemetria) |
| Tipos | só bits e palavras de 16 bits | os do CLP (BOOL, INT, REAL…), mas o cliente é quem diz | o servidor declara o tipo de cada nó | nenhum: o payload é texto ou bytes |
| O que é cada endereço | um mapa em documento à parte | uma tabela de variáveis à parte | o próprio servidor descreve (browse) | combinado entre as partes |
| Como o dado chega | varredura: o cliente pergunta a cada x s | varredura | assinatura: o servidor avisa quando muda | publicação: quem tem o dado envia |
| Quem é servidor | o equipamento (escravo) | o CLP | o equipamento | o broker; equipamento e SCADA são clientes |
Objetivos
- Subir um simulador de equipamento em contêiner, ligado à rede do stack do curso.
- Entender o modelo de dados de cada protocolo: registradores (Modbus), blocos de dados com endereço em bytes (S7) e nós com nome e tipo (OPC-UA).
- Ler e escrever pelos três no Node-RED, com o mínimo de nós, incluindo a escala (×10) do Modbus.
- Comparar varredura (Modbus e S7), assinatura (OPC-UA) e publicação (MQTT).
Material
- Stack Docker do curso (o LAB IoT do
lab08-x): mosquitto e Node-RED comnode-red-contrib-modbus,node-red-contrib-s7enode-red-contrib-opcua, que já vêm na imagem. - O simulador
camara-sim, na pastacamara-sim/do repositório do grupo. - Sem ESP32 nem Wokwi nesta aula. O "equipamento" é o simulador.
- Opcional: UaExpert (Unified Automation, gratuito com cadastro), para navegar no servidor OPC-UA.
O mesmo modelo térmico da câmara dos Labs 05 a 07: aquecedor, perdas para o ambiente,
umidade que cai quando a câmara aquece, ruído do DHT22 e o controle ON/OFF do "firmware".
Com SIM_SPEED=5, a dinâmica fica 5× mais rápida. Ele não simula a segurança do
OPC-UA: o servidor aceita qualquer cliente, sem senha e sem criptografia (P4).
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/lab08-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-a/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-a.git && cd lab08-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-b/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-b.git && cd lab08-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-c/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-c.git && cd lab08-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-d/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-d.git && cd lab08-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-e/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-e.git && cd lab08-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-f/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-f.git && cd lab08-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-g/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-g.git && cd lab08-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-h/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-h.git && cd lab08-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-i/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-i.git && cd lab08-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-j/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-j.git && cd lab08-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-k/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-k.git && cd lab08-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-l/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-l.git && cd lab08-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-m/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-m.git && cd lab08-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-x/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-x.git && cd lab08-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-p/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-p.git && cd lab08-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab08-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab08-grupo-n/commits/main/
- Acessos: ACESSO-LAB08.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/lab08-grupo-n.git && cd lab08-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab08-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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 08:
- 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 — 5 tarefas · 100 pts
- T1 — Simulador na rede do stack · 15 pts
- T2 — Modbus TCP · 25 pts
- T3 — S7: o DB1 · 20 pts
- T4 — OPC-UA: assinatura e escrita · 20 pts
- T5 — Uma planta, quatro portas · 20 pts
O repositório do grupo nasce do lab08-template, que traz uma cópia do simulador em
camara-sim/:
Estrutura de Arquivos do Projeto
- ├── 📂camara-sim
- ├── 📄camara_sim.py👈 Verificar
- ├── 📄camara_model.py👈 Verificar
- ├── 📄proto_modbus.py👈 Verificar
- ├── 📄proto_s7.py👈 Verificar
- ├── 📄proto_opcua.py👈 Verificar
- ├── 📄proto_mqtt.py👈 Verificar
- ├── 📄testar_clientes.py👈 Verificar
- ├── 📄Dockerfile👈 Verificar
- ├── 🚀docker-compose.yml👈 Verificar
- ├── 🚀docker-compose.lab.yml👈 Verificar
- ├── 📄.env.example👈 Verificar
- ├── 📄.env👈 Criar Aqui
- └── 📝README.md👈 Verificar
- ├── 📂nodered
- └── 🔧flows-lab08.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t1-testar.txt👈 Criar Aqui
- ├── 📄t2-modbus.txt👈 Criar Aqui
- ├── 📄t3-s7.txt👈 Criar Aqui
- ├── 📄t4-opcua.txt👈 Criar Aqui
- └── 📄t5-contagem.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 | lab08-x-camara |
| Tópico base MQTT | elt85b/lab08/grupo-x/camara |
| Rede do stack do curso | lab08-x_labnet |
| LAB IoT do lab08-x | http://localhost |
Parte 1 — O simulador na rede do stack
O simulador não traz broker nem Node-RED: ele entra na rede do stack, onde já estão o
mosquitto e o node-red. Lá dentro, o Node-RED o encontra pelo nome lab08-x-camara,
como encontraria um CLP pelo nome na rede da fábrica.
1.1 Subir
- Na pasta
camara-sim/do repositório, crie o.env:
- └── 📂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=lab08-a
MQTT_BASE=elt85b/lab08/grupo-a/camara
LAB_REDE=lab08-a_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-b
MQTT_BASE=elt85b/lab08/grupo-b/camara
LAB_REDE=lab08-b_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-c
MQTT_BASE=elt85b/lab08/grupo-c/camara
LAB_REDE=lab08-c_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-d
MQTT_BASE=elt85b/lab08/grupo-d/camara
LAB_REDE=lab08-d_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-e
MQTT_BASE=elt85b/lab08/grupo-e/camara
LAB_REDE=lab08-e_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-f
MQTT_BASE=elt85b/lab08/grupo-f/camara
LAB_REDE=lab08-f_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-g
MQTT_BASE=elt85b/lab08/grupo-g/camara
LAB_REDE=lab08-g_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-h
MQTT_BASE=elt85b/lab08/grupo-h/camara
LAB_REDE=lab08-h_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-i
MQTT_BASE=elt85b/lab08/grupo-i/camara
LAB_REDE=lab08-i_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-j
MQTT_BASE=elt85b/lab08/grupo-j/camara
LAB_REDE=lab08-j_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-k
MQTT_BASE=elt85b/lab08/grupo-k/camara
LAB_REDE=lab08-k_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-l
MQTT_BASE=elt85b/lab08/grupo-l/camara
LAB_REDE=lab08-l_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-m
MQTT_BASE=elt85b/lab08/grupo-m/camara
LAB_REDE=lab08-m_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-x
MQTT_BASE=elt85b/lab08/grupo-x/camara
LAB_REDE=lab08-x_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-p
MQTT_BASE=elt85b/lab08/grupo-p/camara
LAB_REDE=lab08-p_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
1. Arquivo .env:
GRUPO=lab08-n
MQTT_BASE=elt85b/lab08/grupo-n/camara
LAB_REDE=lab08-n_labnet
SIM_SPEED=5
PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840
- Suba o simulador com o complemento de rede (
docker-compose.lab.yml), que o liga à rede do stack e aponta o MQTT para omosquitto:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-a\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-a-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-a, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-a/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-a/camara/cmd e elt85b/lab08/grupo-a/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-b\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-b-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-b, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-b/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-b/camara/cmd e elt85b/lab08/grupo-b/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-c\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-c-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-c, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-c/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-c/camara/cmd e elt85b/lab08/grupo-c/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-d\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-d-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-d, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-d/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-d/camara/cmd e elt85b/lab08/grupo-d/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-e\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-e-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-e, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-e/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-e/camara/cmd e elt85b/lab08/grupo-e/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-f\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-f-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-f, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-f/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-f/camara/cmd e elt85b/lab08/grupo-f/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-g\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-g-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-g, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-g/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-g/camara/cmd e elt85b/lab08/grupo-g/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-h\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-h-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-h, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-h/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-h/camara/cmd e elt85b/lab08/grupo-h/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-i\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-i-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-i, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-i/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-i/camara/cmd e elt85b/lab08/grupo-i/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-j\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-j-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-j, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-j/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-j/camara/cmd e elt85b/lab08/grupo-j/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-k\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-k-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-k, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-k/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-k/camara/cmd e elt85b/lab08/grupo-k/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-l\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-l-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-l, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-l/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-l/camara/cmd e elt85b/lab08/grupo-l/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-m\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-m-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-m, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-m/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-m/camara/cmd e elt85b/lab08/grupo-m/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-x\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-x-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-x, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-x/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-x/camara/cmd e elt85b/lab08/grupo-x/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-p\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-p-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-p, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-p/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-p/camara/cmd e elt85b/lab08/grupo-p/camara/cmd/+
1. 0. Pasta camara-sim:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-n\camara-sim
2. 1. Subir:
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
3. 2. Logs:
docker logs -f lab08-n-camara
4. 3. Saída esperada:
[planta] câmara climática simulada do lab08-n, speed=5.0x
[s7] servidor na porta 102 (DB1, I, Q, M)
[modbus] TCP em 0.0.0.0:502 (unit 1)
[modbus] RTU sobre TCP em 0.0.0.0:5021
[opcua] opc.tcp://<host>:4840/ (escutando em 0.0.0.0) 'urn:utfpr:camara-climatica' = ns=2
[mqtt] conectando a mosquitto:1883, base 'elt85b/lab08/grupo-n/camara'
[mqtt] conectado; assinando elt85b/lab08/grupo-n/camara/cmd e elt85b/lab08/grupo-n/camara/cmd/+
Se o up reclamar de port is already allocated, outro programa do PC já usa a porta (o mais
comum é a 502 ou a 102). Troque só o lado do PC no .env, por exemplo PORTA_MODBUS_TCP=1502.
Dentro da rede, o Node-RED continua usando 502 e 102: o mapeamento de portas só vale para
quem acessa de fora (o seu PC).
1.2 Testar todos os protocolos
O testar_clientes.py escreve o setpoint por um protocolo e lê pelos outros. Ele roda
dentro do contêiner, onde já conhece o tópico base. Na raiz do repositório:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-a
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-a-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-b
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-b-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-c
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-c-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-d
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-d-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-e
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-e-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-f
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-f-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-g
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-g-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-h
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-h-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-i
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-i-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-j
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-j-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-k
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-k-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-l
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-l-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-m
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-m-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-x
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-x-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-p
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-p-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
1. 0. Raiz do repositório:
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-n
if not exist evidencias mkdir evidencias
2. 1. Testar e gravar:
docker exec lab08-n-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
MQTT escreve SP=36.0 {'temp': 37.0, 'umid': 35.8, 'setpoint': 36.0, 'estado_txt': 'ESTAVEL', 'aquecedor_pwm': 0.0}
Modbus TCP lê {'temp': 36.9, 'umid': 35.1, 'sp': 36.0, 'sp_ef': 36.0, 'aq': 0, 've': 20, 'estado': 3, 'leds(v,a,r)': [1, 0, 0]}
Modbus TCP escreve SP=37.5 ok
S7 lê {'temp': 36.7, 'umid': 35.4, 'sp': 37.5, 'sp_ef': 37.5, 'aq': 100.0, 've': 20.0, 'estado': 3}
S7 escreve SP=38.0 ok
OPC-UA lê {'temp': 36.9, 'umid': 35.4, 'setpoint': 38.0, 'sp_efetivo': 38.0, ...}
OPC-UA escreve SP=39.0 ok
Modbus RTU/TCP lê {'temp': 37.7, 'umid': 32.8, 'sp': 39.0, 'sp_ef': 39.0, 'aq': 100, 've': 20, 'estado': 1, ...}
MQTT escreve SP=35.0 e lê {'temp': 38.6, 'umid': 32.8, 'setpoint': 35.0, 'estado_txt': 'RESFRIANDO', 'aquecedor_pwm': 0.0}
Siga a "corrente" do setpoint: o que o MQTT escreveu (36,0) o Modbus lê; o que o Modbus escreveu (37,5) o S7 lê; e assim por diante. É uma planta com várias portas de acesso.
1.3 Conferir os endereços para o Node-RED
Dentro do Node-RED, os endereços são os nomes dos contêineres na rede labnet, e não
localhost nem o IP do PC: o localhost do Node-RED é o próprio contêiner do Node-RED. Três
comandos conferem tudo antes de montar o fluxo.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-a_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-a-nodered node -e "for(const[h,p]of[['lab08-a-camara',502],['lab08-a-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-b_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-b-nodered node -e "for(const[h,p]of[['lab08-b-camara',502],['lab08-b-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-c_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-c-nodered node -e "for(const[h,p]of[['lab08-c-camara',502],['lab08-c-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-d_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-d-nodered node -e "for(const[h,p]of[['lab08-d-camara',502],['lab08-d-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-e_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-e-nodered node -e "for(const[h,p]of[['lab08-e-camara',502],['lab08-e-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-f_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-f-nodered node -e "for(const[h,p]of[['lab08-f-camara',502],['lab08-f-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-g_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-g-nodered node -e "for(const[h,p]of[['lab08-g-camara',502],['lab08-g-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-h_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-h-nodered node -e "for(const[h,p]of[['lab08-h-camara',502],['lab08-h-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-i_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-i-nodered node -e "for(const[h,p]of[['lab08-i-camara',502],['lab08-i-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-j_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-j-nodered node -e "for(const[h,p]of[['lab08-j-camara',502],['lab08-j-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-k_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-k-nodered node -e "for(const[h,p]of[['lab08-k-camara',502],['lab08-k-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-l_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-l-nodered node -e "for(const[h,p]of[['lab08-l-camara',502],['lab08-l-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-m_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-m-nodered node -e "for(const[h,p]of[['lab08-m-camara',502],['lab08-m-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-x_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-x-nodered node -e "for(const[h,p]of[['lab08-x-camara',502],['lab08-x-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-p_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-p-nodered node -e "for(const[h,p]of[['lab08-p-camara',502],['lab08-p-camara',102],['lab08-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()})}"
1. 1. Endereços do LAB IoT:
type credenciais.txt
2. 2. Quem está na rede:
docker network ls | findstr labnet
docker network inspect lab08-n_labnet --format "{{range .Containers}}{{.Name}} {{end}}"
3. 3. O Node-RED alcança as portas?:
docker exec lab08-n-nodered node -e "for(const[h,p]of[['lab08-n-camara',502],['lab08-n-camara',102],['lab08-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()})}"
- No
credenciais.txt, interessam as linhasNode-RED: <base>/lab08-x/eMQTT: mosquitto:1883 (Node-RED/FUXA), e se o MQTT pede login. - A rede leva o nome da pasta do LAB IoT mais
_labnet(é oLAB_REDEdo.env). A lista tem de incluirlab08-x-mosquitto,lab08-x-noderedelab08-x-camara. Sem olab08-x-camara, o simulador subiu sem odocker-compose.lab.ymlou com outroLAB_REDE. - O teste roda de dentro do contêiner do Node-RED, de onde os nós vão se conectar. As quatro
linhas devem sair
ok.ENOTFOUNDquer dizer que o nome não existe na rede (volte ao passo 2);ECONNREFUSED, que o contêiner existe, mas nada escuta naquela porta.
| Nó de configuração no Node-RED | Endereço |
|---|---|
| modbus-client | lab08-x-camara, porta 502, unit 1 |
| s7 endpoint | lab08-x-camara, porta 102, rack 0 / slot 1 |
| OpcUa-Endpoint | opc.tcp://lab08-x-camara:4840/ |
| mqtt-broker | mosquitto, porta 1883 |
| Editor do Node-RED (navegador) | http://localhost/lab08-x/ |
As portas do .env (PORTA_MODBUS_TCP etc.) só valem para quem acessa de fora, como o
UaExpert em localhost:4840. Dentro da rede, o Node-RED usa sempre 502, 102 e 4840.
--mqtt-sem-anonimoEsta aula usa o padrão do gen_iot_aluno.py, em que o broker aceita clientes sem login. Com
--mqtt-sem-anonimo, o camara-sim (que conecta sem login) é recusado, e o usuário do grupo só
pode usar os tópicos lab08-x/#: os tópicos elt85b/lab08/... são descartados sem aviso. Gere o
LAB IoT sem essa opção.
- ├── 📂camara-sim
- └── 📄.env👈 Criar Aqui
- └── 📂evidencias
- └── 📄t1-testar.txt👈 Criar Aqui
git conferir camara-sim/.env evidencias/t1-testar.txt
Simulador na rede do stack
git conferir camara-sim/.env evidencias/t1-testar.txt
git add camara-sim/.env evidencias/t1-testar.txt && git commit -m "T1: Simulador na rede do stack" && 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 TCP
2.1 O modelo de dados do Modbus
O Modbus não tem nomes nem tipos: só quatro tabelas de endereços numerados, de bits ou de palavras de 16 bits. O significado de cada endereço vem de um mapa de registradores, o documento que o fabricante entrega com o equipamento. Este é o trecho do mapa da câmara que vamos usar (unit 1, endereços a partir de 0):
| Tabela | Função (FC) | Acesso | End. | Variável |
|---|---|---|---|---|
| Coils | FC1 lê · FC5 escreve | bit, R/W | 0 | habilitado |
| Discrete inputs | FC2 | bit, só leitura | 0–2 | LEDs verde, amarelo, vermelho |
| Holding registers | FC3 lê · FC6 escreve | 16 bits, R/W | 3 | setpoint × 10 (350 = 35,0 °C) |
| Input registers | FC4 | 16 bits, só leitura | 0 / 1 / 2 | temperatura × 10 / umidade × 10 / setpoint efetivo × 10 |
| 3 / 4 | aquecedor / ventilador (%) |
O mapa completo está no camara-sim/README.md.
Um registrador guarda só inteiros de 0 a 65535. Para ter uma casa decimal, o valor vai
multiplicado por 10: 35,2 °C viram 352. Quem lê divide; quem escreve multiplica.
2.2 Ler
Crie uma aba Lab 08 no Node-RED e um nó de configuração modbus-client:
| Campo | câmara Modbus TCP |
|---|---|
| Type | TCP |
| Host / Port | lab08-x-camara / 502 |
| TCP Type | DEFAULT |
| Unit-Id | 1 |
- modbus-read "FC4 IR 0..4": FC 4: Read Input Registers, Address
0, Quantity5, Poll Rate2 s. A saída vai a um debug "Modbus (registradores)" e a uma function:
// IR0..4 -> nomes e unidades (o mapa de registradores diz o que é cada um)
const r = msg.payload;
msg.payload = {
temp: r[0] / 10, // IR0: °C x 10
umid: r[1] / 10, // IR1: % x 10
sp_efetivo: r[2] / 10, // IR2: °C x 10
aquecedor: r[3], // IR3: %
ventilador: r[4], // IR4: %
};
return msg;
- Ligue a function a um debug "Modbus" (status:
payload.temp) e faça o Deploy.
Modbus (registradores): [ 362, 363, 350, 0, 20 ]
Modbus: { temp: 36.2, umid: 36.3, sp_efetivo: 35, aquecedor: 0, ventilador: 20 }
Sem o mapa, [362, 363, 350, 0, 20] são só números.
2.3 Escrever
| Nó | Configuração |
|---|---|
| inject "SP 30 °C" / "SP 40 °C" | payload número 30 / 40 |
| function "°C → HR3 (×10)" | msg.payload = Math.round(Number(msg.payload) * 10); return msg; |
| modbus-write "FC6 HR3 setpoint" | FC 6: Preset Single Register, Address 3, Quantity 1 |
| inject "Liga" / "Desliga" | payload booleano true / false |
| modbus-write "FC5 coil 0 habilitado" | FC 5: Force Single Coil, Address 0, Quantity 1 |
Clique "SP 40 °C": o sp_efetivo do debug vai a 40 e o aquecedor liga. Clique "Desliga": o
aquecedor vai a 0. Cada escrita aparece no log do simulador, com o protocolo de origem:
docker logs lab08-x-camara 2>&1 | findstr /l /c:"[cmd]"
[15:45:03] [cmd] modbus: setpoint = 40.0
[15:45:08] [cmd] modbus coil: habilitado = False
[15:45:12] [cmd] modbus coil: habilitado = True
- Float32 em dois registradores: para não perder precisão, muitos equipamentos guardam um
floatde 32 bits em dois registradores seguidos. A ordem das palavras (ABCD, CDAB…) muda de fabricante para fabricante, e errar a ordem dá números absurdos. A câmara faz isso nos IR12–13 (temperatura). - Modbus RTU: o mesmo protocolo na linha serial RS-485, com o quadro endereço + função + dados + CRC-16. A câmara também responde em RTU (porta 5021, "RTU sobre TCP", como um conversor serial-Ethernet), mas não vamos usá-la hoje.
P1: (a) o que acontece se você esquecer a function "×10" e mandar 37.5 direto para o HR3?
(Dica: o registrador só guarda inteiros, e o simulador limita o setpoint a 20…55 °C.) Teste e
confira no debug e no log. (b) O equipamento avisou algum erro? Por que não?
Evidência: em evidencias/t2-modbus.txt, cole uma mensagem de cada debug ("registradores"
e "Modbus") e as linhas [cmd] do log.
- └── 📂evidencias
- └── 📄t2-modbus.txt👈 Criar Aqui
git conferir evidencias/t2-modbus.txt
Modbus TCP
git conferir evidencias/t2-modbus.txt
git add evidencias/t2-modbus.txt && git commit -m "T2: Modbus TCP" && 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: o DB1
3.1 O modelo de dados do S7
Num CLP Siemens, os dados do programa ficam em blocos de dados (DB). Um DB é uma sequência
de bytes, e cada variável é um tipo num deslocamento (offset): REAL (float) ocupa
4 bytes, INT 2 bytes, e um BOOL é um bit de um byte. O protocolo S7 (ISO-on-TCP,
porta 102) lê e escreve faixas desses bytes. O cliente precisa saber o endereço e o tipo
de cada variável.
| Endereço (nodes7) | Bytes | Variável | Acesso |
|---|---|---|---|
DB1,X0.0 | bit 0 do byte 0 | habilitado | R/W |
DB1,INT2 | 2–3 | modo | R/W |
DB1,REAL4 | 4–7 | setpoint (°C) | R/W |
DB1,REAL20 | 20–23 | temp (°C) | R |
DB1,REAL24 | 24–27 | umid (%) | R |
DB1,REAL28 | 28–31 | sp_efetivo (°C) | R |
DB1,INT40 | 40–41 | estado (0 DESLIGADO … 4 ALARME) | R |
Repare que não há escala: o REAL já é o valor em °C.
3.2 Ler e escrever
Crie um nó de configuração s7 endpoint "câmara S7 (DB1)":
| Campo | Valor |
|---|---|
| Transport | Ethernet (ISO-on-TCP) |
| Address / Port | lab08-x-camara / 102 |
| Mode | Rack/Slot: 0 / 1 |
| Cycle time | 2000 ms |
| Variables | habilitado, setpoint, temp, umid, sp_efetivo e estado, com os endereços da tabela (o modo fica de fora) |
- s7 in, Mode All variables → debug "S7" (status:
payload.temp). A cada ciclo, chega um objeto com todas as variáveis da tabela. - s7 out, Variable
setpoint, alimentado por injects33e43.
{ habilitado: true, setpoint: 36, temp: 36.400001525878906, umid: 37.099998474121094, sp_efetivo: 36, estado: 3 }
O 36.400001525878906 não é erro: 36,4 não tem representação exata em float de 32 bits, e o
Node-RED (JavaScript) mostra o número com a precisão de 64 bits.
Escreva SP 43 °C pelo S7 e confira, no debug "Modbus", que o sp_efetivo também mudou.
P2: um colega declarou o setpoint como DB1,REAL2, em vez de DB1,REAL4, e escreveu 40.
Quais bytes do DB1 foram alterados? O que acontece com o modo (bytes 2–3)? Por que o S7 não
avisa nada?
Evidência: em evidencias/t3-s7.txt, uma mensagem do debug "S7" e as linhas [cmd] s7: do
log do simulador.
- └── 📂evidencias
- └── 📄t3-s7.txt👈 Criar Aqui
git conferir evidencias/t3-s7.txt
S7: o DB1
git conferir evidencias/t3-s7.txt
git add evidencias/t3-s7.txt && git commit -m "T3: S7: o DB1" && 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: assinatura e escrita
4.1 O modelo de dados do OPC-UA
No OPC-UA, o servidor publica um espaço de endereçamento: uma árvore de nós, cada um com nome, tipo, unidade e permissões. O cliente não precisa de um mapa externo: ele navega (browse) e descobre. Cada nó tem um NodeId. Na câmara:
Medicoes/ temp · umid ns=2;s=Camara.temp ...
Atuadores/ aquecedor_pwm · ventilador_pwm
Estado/ estado · estado_txt · heartbeat · ...
Comandos/ habilitado · modo · setpoint · ... (graváveis)
E o dado não precisa ser perguntado a cada 2 s. O cliente faz uma assinatura (subscription): "me avise quando este nó mudar, verificando a cada 2 s".
No PC, conecte o UaExpert em opc.tcp://localhost:4840/ (Security None, anônimo). Navegue até
Objects/Camara e arraste temp, setpoint e estado_txt para o Data Access View. Repare
nos atributos de cada nó: DataType, AccessLevel e Description. Nenhum mapa foi preciso.
4.2 Assinar e escrever no Node-RED
Crie um OpcUa-Endpoint "câmara OPC-UA": opc.tcp://lab08-x-camara:4840/, Security
Policy None, Mode None, anônimo.
- Dois inject que disparam uma vez (Inject once after 3 s), com o NodeId no topic:
ns=2;s=Camara.tempens=2;s=Camara.setpoint. Cada mensagem cria uma assinatura. - OpcUa-Client "assina (2 s)": Action SUBSCRIBE, Interval
2s → debug "OPC-UA". Cada mudança chega numa mensagem, com o NodeId nomsg.topice o valor nomsg.payload. A primeira mensagem (topic: subscriptionId) só informa o número da assinatura. - Para escrever: inject
35→ OpcUa-Item (Itemns=2;s=Camara.setpoint, TypeDouble) → OpcUa-Client "escreve", Action WRITE.
O tipo tem de bater com o do servidor: escrever um Float num nó Double é recusado com
BadTypeMismatch. Ao contrário do S7, o OPC-UA sabe o tipo e avisa.
P3: a câmara está estável, a temperatura oscila um pouco por causa do ruído do sensor, e
ninguém mexe no setpoint. Em 1 minuto, quantas mensagens de temp e quantas de setpoint o
OPC-UA entrega? E quantas leituras o Modbus faz no mesmo minuto? Responda antes e confira na T5.
Evidência: em evidencias/t4-opcua.txt, algumas mensagens do debug "OPC-UA" (com o
topic) e as linhas [cmd] opcua: do log do simulador.
- └── 📂evidencias
- └── 📄t4-opcua.txt👈 Criar Aqui
git conferir evidencias/t4-opcua.txt
OPC-UA: assinatura e escrita
git conferir evidencias/t4-opcua.txt
git add evidencias/t4-opcua.txt && git commit -m "T4: OPC-UA: assinatura e escrita" && 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.
Projeto integrador — uma planta, quatro portas
Falta o quarto caminho, o MQTT, que você já conhece. Com ele, a aba Lab 08 fica com uma leitura e uma escrita por protocolo, e dá para comparar os quatro lado a lado.
Requisitos
-
MQTT. Um nó de configuração mqtt-broker (
mosquitto, porta1883) e:- mqtt in
elt85b/lab08/grupo-x/camara/telemetria(Output: a parsed JSON object) → debug "MQTT" (status:payload.temp); - inject
36→ mqtt outelt85b/lab08/grupo-x/camara/cmd/setpoint.
- mqtt in
-
O setpoint por cada porta. Escreva o setpoint uma vez por protocolo, com uns 10 s entre as escritas: Modbus (40), S7 (33), OPC-UA (35) e MQTT (36). Depois de cada escrita, anote o que os quatro debugs mostram. No
README.md:README.md## T5 — Uma planta, quatro portas| Escrito por | Valor | Modbus lê (`sp_efetivo`) | S7 lê (`setpoint`) | OPC-UA lê (`setpoint`) | MQTT lê (`setpoint`) || ------------------- | ----- | ------------------------ | ------------------ | ---------------------- | -------------------- || Modbus (FC6 HR3) | 40 | | | | || S7 (DB1,REAL4) | 33 | | | | || OPC-UA (Double) | 35 | | | | || MQTT (cmd/setpoint) | 36 | | | | | -
Contar as mensagens. Em cada um dos debugs "Modbus", "S7", "OPC-UA" e "MQTT", troque o status para contador de mensagem (message count) e faça o Deploy (o Deploy zera os contadores). Sem escrever nada, espere 1 minuto e capture a aba em
evidencias/t5-contagem.png. Anote os números noREADME.md.Debug Mensagens em 1 min Por quê Modbus varredura a cada 2 s S7 varredura a cada 2 s (Cycle time) OPC-UA uma por mudança de tempou desetpointMQTT o equipamento publica a cada 2 s No debug "OPC-UA", filtre a barra lateral pelo nó e confira: quantas mensagens são de
Camara.setpoint? -
Exporte o fluxo: Menu ☰ → Export → Current flow → Download, e salve como
nodered/flows-lab08.json. -
No
README.md: as respostas de P1 a P4.
P4: nenhum dos caminhos desta aula pediu usuário ou senha. (a) Quem, na mesma rede, poderia mudar o setpoint da câmara? (b) O que o OPC-UA oferece para evitar isso (veja as opções de Security Policy e Mode do OpcUa-Endpoint) que o Modbus não tem? (c) Por que, mesmo assim, redes industriais costumam ficar separadas da rede do escritório e da internet?
- ├── 📂nodered
- └── 🔧flows-lab08.json👈 Criar Aqui
- ├── 📂evidencias
- └── 📄t5-contagem.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir nodered/flows-lab08.json evidencias/t5-contagem.png README.md
Uma planta, quatro portas
git conferir nodered/flows-lab08.json evidencias/t5-contagem.png README.md
git add nodered/flows-lab08.json evidencias/t5-contagem.png README.md && git commit -m "T5: Uma planta, quatro portas" && 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.
Referência rápida
| Protocolo | Nó de configuração | Ler | Escrever |
|---|---|---|---|
| Modbus TCP | modbus-client lab08-x-camara:502, unit 1 | modbus-read (FC1/2/3/4, endereço, quantidade, intervalo) | modbus-write (FC5 bobina, FC6 registrador) |
| S7 | s7 endpoint lab08-x-camara:102, rack 0, slot 1, tabela de variáveis | s7 in (uma variável ou todas) | s7 out (uma variável) |
| OPC-UA | OpcUa-Endpoint opc.tcp://lab08-x-camara:4840/ | OpcUa-Client READ ou SUBSCRIBE, NodeId no msg.topic | OpcUa-Item (NodeId + tipo) → OpcUa-Client WRITE |
| MQTT | mqtt-broker mosquitto:1883 | mqtt in (tópico) | mqtt out (tópico) |
| Problema | O que fazer |
|---|---|
| Nó Modbus/S7/OPC-UA "desconectado" | o simulador está na rede do stack? docker logs lab08-x-camara; no Node-RED, o host é lab08-x-camara, e não localhost |
| Nós Modbus com "propriedades inválidas: Server" | no modbus-client, o campo Serial port não pode ficar vazio, mesmo com Type TCP: mude o Type para Serial, preencha /dev/ttyUSB, volte para TCP e faça o Deploy |
port is already allocated no up | troque a porta do lado do PC no .env |
| Setpoint "errado" pelo Modbus | faltou o ×10 (P1) |
| Valores sem sentido no S7 | endereço ou tipo errado na tabela de variáveis (P2) |
BadTypeMismatch no OPC-UA | o Type do OpcUa-Item tem de ser o do nó (Double para o setpoint) |
| Nada chega no debug "MQTT" | o tópico tem de ser idêntico ao MQTT_BASE do .env, mais /telemetria |
| Parar o simulador | na pasta camara-sim: docker compose -f docker-compose.yml -f docker-compose.lab.yml down |
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.