Pular para o conteúdo principal

Laboratório 08

Checklist — protocolos industriais: Modbus, S7 e OPC-UA (conceitos iniciais)​

  • camara-sim rodando na rede do stack do curso, com o testar_clientes.py passando (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 commit Tn:
  • Logout do Git e do gh no computador do laboratório
Pontuação

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.

Antes de começar

Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):

Verificação rápida das versões instaladas:

git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version

Verificação rápida de autenticação e alias:

git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"

Adicionar o comando git conferir:

git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"

Configuração do ambiente de desenvolvimento​

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

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

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

    git config --list --show-origin

Antes de começar

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

docker desktop start

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

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

Disciplina: ELT85B - IoT Industrial.

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

set "IOT_REPO=%USERPROFILE%\ELT85BN21\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))
Precisa de mais?

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 TCPS7OPC-UAMQTT
OrigemModicon, 1979 (serial); abertoSiemens; proprietárioOPC Foundation; aberto (IEC 62541)IBM, 1999; aberto (OASIS)
Como o dado é endereçadonúmero do registrador (IR0, HR3)bloco + byte (DB1,REAL20)nó com nome (ns=2;s=Camara.temp)tópico (.../telemetria)
Tipossó bits e palavras de 16 bitsos do CLP (BOOL, INT, REAL…), mas o cliente é quem dizo servidor declara o tipo de cada nónenhum: o payload é texto ou bytes
O que é cada endereçoum mapa em documento à parteuma tabela de variáveis à parteo próprio servidor descreve (browse)combinado entre as partes
Como o dado chegavarredura: o cliente pergunta a cada x svarreduraassinatura: o servidor avisa quando mudapublicação: quem tem o dado envia
Quem é servidoro equipamento (escravo)o CLPo equipamentoo 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 com node-red-contrib-modbus, node-red-contrib-s7 e node-red-contrib-opcua, que já vêm na imagem.
  • O simulador camara-sim, na pasta camara-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 que o camara-sim simula

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​

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"

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

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

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

Mapa de tarefas — 5 tarefas · 100 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
📂 lab08-grupo-x/
  • ├── 📂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
Nomes do Lab 08

Troque o x pela letra do seu grupo em todos os nomes abaixo.

O quêValor
Contêiner e host na redelab08-x-camara
Tópico base MQTTelt85b/lab08/grupo-x/camara
Rede do stack do cursolab08-x_labnet
LAB IoT do lab08-xhttp://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​

  1. Na pasta camara-sim/ do repositório, crie o .env:
📂 lab08-grupo-x/
  • └── 📂camara-sim
    • └── 📄.env👈 Criar Aqui
git conferir camara-sim/.env

1. Arquivo .env:

camara-sim/.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. Suba o simulador com o complemento de rede (docker-compose.lab.yml), que o liga à rede do stack e aponta o MQTT para o mosquitto:

1. 0. Pasta camara-sim:

Terminal (cmd)
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-a\camara-sim

2. 1. Subir:

Terminal (cmd), na pasta camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build

3. 2. Logs:

Terminal (cmd)
docker logs -f lab08-a-camara

4. 3. Saída esperada:

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/+
Porta ocupada?

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:

1. 0. Raiz do repositório:

Terminal (cmd)
cd /d %USERPROFILE%\ELT85BN21\lab08-grupo-a
if not exist evidencias mkdir evidencias

2. 1. Testar e gravar:

Terminal (cmd)
docker exec lab08-a-camara python testar_clientes.py --mqtt-host mosquitto > evidencias\t1-testar.txt
type evidencias\t1-testar.txt
evidencias/t1-testar.txt (exemplo)
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.

1. 1. Endereços do LAB IoT:

Terminal (cmd), na pasta do LAB IoT (lab08-a)
type credenciais.txt

2. 2. Quem está na rede:

Terminal (cmd)
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?:

Terminal (cmd)
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. No credenciais.txt, interessam as linhas Node-RED: <base>/lab08-x/ e MQTT: mosquitto:1883 (Node-RED/FUXA), e se o MQTT pede login.
  2. A rede leva o nome da pasta do LAB IoT mais _labnet (é o LAB_REDE do .env). A lista tem de incluir lab08-x-mosquitto, lab08-x-nodered e lab08-x-camara. Sem o lab08-x-camara, o simulador subiu sem o docker-compose.lab.yml ou com outro LAB_REDE.
  3. 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. ENOTFOUND quer 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-REDEndereço
modbus-clientlab08-x-camara, porta 502, unit 1
s7 endpointlab08-x-camara, porta 102, rack 0 / slot 1
OpcUa-Endpointopc.tcp://lab08-x-camara:4840/
mqtt-brokermosquitto, 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.

LAB IoT gerado com --mqtt-sem-anonimo

Esta 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.

📂 lab08-grupo-x/
  • ├── 📂camara-sim
    • └── 📄.env👈 Criar Aqui
  • └── 📂evidencias
    • └── 📄t1-testar.txt👈 Criar Aqui
git conferir camara-sim/.env evidencias/t1-testar.txt
Ponto de commit · T1 (15 pts) #

Simulador na rede do stack

1. Conferir os arquivos
git conferir camara-sim/.env evidencias/t1-testar.txt
2. Commit T1 e push
git add camara-sim/.env evidencias/t1-testar.txt && git commit -m "T1: Simulador na rede do stack" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.


Parte 2 — 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):

TabelaFunção (FC)AcessoEnd.Variável
CoilsFC1 lê · FC5 escrevebit, R/W0habilitado
Discrete inputsFC2bit, só leitura0–2LEDs verde, amarelo, vermelho
Holding registersFC3 lê · FC6 escreve16 bits, R/W3setpoint × 10 (350 = 35,0 °C)
Input registersFC416 bits, só leitura0 / 1 / 2temperatura × 10 / umidade × 10 / setpoint efetivo × 10
3 / 4aquecedor / ventilador (%)

O mapa completo está no camara-sim/README.md.

Escala ×10

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:

Campocâmara Modbus TCP
TypeTCP
Host / Portlab08-x-camara / 502
TCP TypeDEFAULT
Unit-Id1
  • modbus-read "FC4 IR 0..4": FC 4: Read Input Registers, Address 0, Quantity 5, Poll Rate 2 s. A saída vai a um debug "Modbus (registradores)" e a uma function:
function: ÷10 e nomes
// 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.
Debug (o que chega do equipamento × o que ele significa)
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:

Terminal (cmd)
docker logs lab08-x-camara 2>&1 | findstr /l /c:"[cmd]"
Saída esperada (trecho)
[15:45:03] [cmd] modbus: setpoint = 40.0
[15:45:08] [cmd] modbus coil: habilitado = False
[15:45:12] [cmd] modbus coil: habilitado = True
Dois conceitos que você vai encontrar em equipamentos reais
  • Float32 em dois registradores: para não perder precisão, muitos equipamentos guardam um float de 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.
Preveja antes de rodar

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.

📂 lab08-grupo-x/
  • └── 📂evidencias
    • └── 📄t2-modbus.txt👈 Criar Aqui
git conferir evidencias/t2-modbus.txt
Ponto de commit · T2 (25 pts) #

Modbus TCP

1. Conferir os arquivos
git conferir evidencias/t2-modbus.txt
2. Commit T2 e push
git add evidencias/t2-modbus.txt && git commit -m "T2: Modbus TCP" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.


Parte 3 — 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)BytesVariávelAcesso
DB1,X0.0bit 0 do byte 0habilitadoR/W
DB1,INT22–3modoR/W
DB1,REAL44–7setpoint (°C)R/W
DB1,REAL2020–23temp (°C)R
DB1,REAL2424–27umid (%)R
DB1,REAL2828–31sp_efetivo (°C)R
DB1,INT4040–41estado (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)":

CampoValor
TransportEthernet (ISO-on-TCP)
Address / Portlab08-x-camara / 102
ModeRack/Slot: 0 / 1
Cycle time2000 ms
Variableshabilitado, 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 injects 33 e 43.
Debug S7
{ 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.

Preveja antes de rodar

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.

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

S7: o DB1

1. Conferir os arquivos
git conferir evidencias/t3-s7.txt
2. Commit T3 e push
git add evidencias/t3-s7.txt && git commit -m "T3: S7: o DB1" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.


Parte 4 — 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:

Objects/Camara (namespace urn:utfpr:camara-climatica = ns=2)
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".

Opcional: UaExpert

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.temp e ns=2;s=Camara.setpoint. Cada mensagem cria uma assinatura.
  • OpcUa-Client "assina (2 s)": Action SUBSCRIBE, Interval 2 s → debug "OPC-UA". Cada mudança chega numa mensagem, com o NodeId no msg.topic e o valor no msg.payload. A primeira mensagem (topic: subscriptionId) só informa o número da assinatura.
  • Para escrever: inject 35 → OpcUa-Item (Item ns=2;s=Camara.setpoint, Type Double) → 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.

Preveja antes de rodar

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.

📂 lab08-grupo-x/
  • └── 📂evidencias
    • └── 📄t4-opcua.txt👈 Criar Aqui
git conferir evidencias/t4-opcua.txt
Ponto de commit · T4 (20 pts) #

OPC-UA: assinatura e escrita

1. Conferir os arquivos
git conferir evidencias/t4-opcua.txt
2. Commit T4 e push
git add evidencias/t4-opcua.txt && git commit -m "T4: OPC-UA: assinatura e escrita" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.


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​

  1. MQTT. Um nó de configuração mqtt-broker (mosquitto, porta 1883) e:

    • mqtt in elt85b/lab08/grupo-x/camara/telemetria (Output: a parsed JSON object) → debug "MQTT" (status: payload.temp);
    • inject 36 → mqtt out elt85b/lab08/grupo-x/camara/cmd/setpoint.
  2. 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 | | | | |
  3. 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 no README.md.

    DebugMensagens em 1 minPor quê
    Modbusvarredura a cada 2 s
    S7varredura a cada 2 s (Cycle time)
    OPC-UAuma por mudança de temp ou de setpoint
    MQTTo 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?

  4. Exporte o fluxo: Menu ☰ → Export → Current flow → Download, e salve como nodered/flows-lab08.json.

  5. No README.md: as respostas de P1 a P4.

Preveja antes de rodar

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?

📂 lab08-grupo-x/
  • ├── 📂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
Ponto de commit · T5 (20 pts) #

Uma planta, quatro portas

1. Conferir os arquivos
git conferir nodered/flows-lab08.json evidencias/t5-contagem.png README.md
2. Commit T5 e push
git add nodered/flows-lab08.json evidencias/t5-contagem.png README.md && git commit -m "T5: Uma planta, quatro portas" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T5.


Referência rápida​

ProtocoloNó de configuraçãoLerEscrever
Modbus TCPmodbus-client lab08-x-camara:502, unit 1modbus-read (FC1/2/3/4, endereço, quantidade, intervalo)modbus-write (FC5 bobina, FC6 registrador)
S7s7 endpoint lab08-x-camara:102, rack 0, slot 1, tabela de variáveiss7 in (uma variável ou todas)s7 out (uma variável)
OPC-UAOpcUa-Endpoint opc.tcp://lab08-x-camara:4840/OpcUa-Client READ ou SUBSCRIBE, NodeId no msg.topicOpcUa-Item (NodeId + tipo) → OpcUa-Client WRITE
MQTTmqtt-broker mosquitto:1883mqtt in (tópico)mqtt out (tópico)
ProblemaO 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 uptroque a porta do lado do PC no .env
Setpoint "errado" pelo Modbusfaltou o ×10 (P1)
Valores sem sentido no S7endereço ou tipo errado na tabela de variáveis (P2)
BadTypeMismatch no OPC-UAo 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 simuladorna 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
Ao terminar — máquina de laboratório

Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.

1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:

(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email

Para conferir, este comando não deve mostrar nada:

cmdkey /list | findstr /i github

2. Pare os containers do lab:

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

3. No navegador, saia da sua conta em github.com e feche todas as janelas.