Pular para o conteúdo principal

Laboratório 10

Checklist — SCADA da câmara com FUXA​

  • LAB IoT do lab10-x com a câmara, o fluxo do Lab 09 no Node-RED e os drivers do FUXA instalados (T1)
  • Três conexões no FUXA (OPC-UA, Modbus TCP e MQTT), em verde e com as tags lendo (T2)
  • Sinótico da câmara: estado em cores, valores, barra do aquecedor, setpoint e botões de modo (T3)
  • Dois alarmes, testados e reconhecidos (T4)
  • Histórico e tendência de T, SP e aquecedor (T5)
  • FUXA + Node-RED: o operador escolhe o controlador no FUXA, e um supervisor devolve a câmara ao PI interno se o Node-RED cair (T6)
  • Previsões P1–P4 respondidas no README.md
  • Nenhum push --force; cada tarefa num commit Tn:
  • Logout do Git e do gh no computador do laboratório
Pontuação

T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 20 · T4 15 · T5 15 · T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.

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\lab10-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab10-a"

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

py "%IOT_GEN%" --disciplina elt85b --lab lab10 --grupo a --sem-gitea --sem-microbin --sem-ntfy --captura --saida "%IOT_DIR%"

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

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

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

start http://localhost/

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

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

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


Nos Labs 08 e 09, o Node-RED fez o papel de SCADA: cada leitura, cada escala e cada botão foram programados em nós e funções. Funciona, mas não é assim que se supervisiona uma fábrica. Lá, o operador olha para um sinótico desenhado num software de SCADA/IHM, onde conexões, tags, alarmes e histórico são configurados, e não programados.

Nesta aula, você monta o SCADA da mesma câmara climática no FUXA, um SCADA web de código aberto que já vem no LAB IoT. Tudo o que você aprendeu nos Labs 08 e 09 reaparece, agora como configuração:

No Lab 08/09 (Node-RED)No FUXA
nó de configuração (modbus-client, OpcUa-Endpoint, mqtt-broker)conexão (Connection)
endereço lido por um nó (IR0, ns=2;s=Camara.temp, chave do JSON)tag
function "÷10"campo Divisor da tag
debug, ui-table, ui-chartsinótico, tendência
PI externo (Lab 09, T6)continua no Node-RED; o FUXA escolhe quem controla e vigia

Objetivos​

  • Configurar um SCADA: drivers, conexões e tags.
  • Comparar como cada protocolo é endereçado num SCADA: NodeId (OPC-UA), registrador base 1 com divisor (Modbus) e chave de JSON (MQTT).
  • Desenhar um sinótico: formas e cores ligadas ao estado, valores, barras e comandos.
  • Configurar alarmes com nível, texto e reconhecimento.
  • Registrar histórico e montar uma tendência.
  • (Integrador) Dividir o trabalho entre SCADA e controlador e implementar um supervisor de falha do controlador externo.

Material​

  • O LAB IoT do lab10-x (gerado pelo gen_iot_aluno.py, sem --sem-fuxa): mosquitto, Node-RED e FUXA.
  • O simulador camara-sim, na pasta camara-sim/ do repositório do grupo.
  • O fluxo do Lab 09 (nodered/flows-lab09.json, no repositório do Lab 09).
  • Acesso à internet no primeiro uso: os drivers do FUXA são baixados do npm.
FUXA: o que esta aula usa

O FUXA tem editor (/editor) e runtime (a tela do operador) no mesmo servidor. As conexões rodam no servidor, e não no navegador: 10 operadores com a tela aberta não multiplicam o tráfego com a câmara. A aula não usa usuários e permissões, relatórios, receitas nem o Node-RED embutido do FUXA. Também fica de fora o driver S7: ele não resolve nomes de host e exigiria o IP do contêiner.

Clonar o repositório do grupo​

1. Crie e entre na pasta-mãe da disciplina:

mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"

2. Clone e entre no repositório do laboratório:

git clone https://github.com/ELT85B-N21-2026-2/lab10-grupo-a.git && cd lab10-grupo-a

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

cd /d "%USERPROFILE%\ELT85BN21\lab10-grupo-a" && code . --profile "ESP32IO"

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

  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 — 6 tarefas · 100 pts
Estrutura de Arquivos do Projeto
📂 lab10-grupo-x/
  • ├── 📂camara-sim
    • ├── 🚀docker-compose.yml👈 Verificar
    • ├── 🚀docker-compose.lab.yml👈 Verificar
    • ├── 📄.env.example👈 Verificar
    • └── 📄.env👈 Criar Aqui
  • ├── 📂fuxa
    • └── 🔧projeto-lab10.json👈 Criar Aqui
  • ├── 📂nodered
    • └── 🔧flows-lab10.json👈 Criar Aqui
  • ├── 📂evidencias
    • ├── 📄t1-enderecos.txt👈 Criar Aqui
    • ├── 📄t1-plugins.png👈 Criar Aqui
    • ├── 📄t2-conexoes.png👈 Criar Aqui
    • ├── 📄t3-sinotico.png👈 Criar Aqui
    • ├── 📄t4-alarmes.png👈 Criar Aqui
    • ├── 📄t5-tendencia.png👈 Criar Aqui
    • ├── 📄t6-fallback.png👈 Criar Aqui
    • └── 📄t6-log.txt👈 Criar Aqui
  • └── 📝README.md👈 Edite Aqui
Nomes do Lab 10

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

O quêValor
Câmara (host na rede)lab10-x-camara
Telemetria da câmara (MQTT)elt85b/lab10/grupo-x/camara/telemetria
Estado do PI externo (T6)elt85b/lab10/grupo-x/scada/pi
Node-REDhttp://localhost/lab10-x/ (contêiner lab10-x-nodered)
FUXA: editor / runtimehttp://localhost/fuxa/lab10-x/editor · http://localhost/fuxa/lab10-x/ (contêiner lab10-x-fuxa)
Login do FUXAo usuário e a senha do grupo (credenciais.txt do LAB IoT)

O projeto do FUXA fica dentro do LAB IoT (pasta fuxa/lab10-x/ dele). O que vai para o repositório é a exportação: no menu do projeto (ícone de disquete), Save Project As... baixa o arquivo; salve-o como fuxa/projeto-lab10.json. Exporte de novo ao fim de cada tarefa.


Parte 1 — Câmara, Node-RED e drivers do FUXA​

1.1 A câmara e o fluxo do Lab 09​

O mesmo do Lab 09 (Parte 1), com os nomes do Lab 10:

  1. Câmara: o .env da pasta camara-sim/ com GRUPO=lab10-x, MQTT_BASE=elt85b/lab10/grupo-x/camara, LAB_REDE=lab10-x_labnet e SIM_SPEED=5, e o docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build.
📂 lab10-grupo-x/
  • └── 📂camara-sim
    • └── 📄.env👈 Criar Aqui
git conferir camara-sim/.env

1. Arquivo .env:

camara-sim/.env
GRUPO=lab10-a
MQTT_BASE=elt85b/lab10/grupo-a/camara
LAB_REDE=lab10-a_labnet
SIM_SPEED=5

PORTA_MODBUS_TCP=1502
PORTA_MODBUS_RTU=5021
PORTA_S7=1102
PORTA_OPCUA=4840

2. Subir:

Terminal (cmd)
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-a\camara-sim
docker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build
docker logs lab10-a-camara

3. Quem está na rede:

Terminal (cmd), na raiz do repositório
cd /d %USERPROFILE%\ELT85BN21\lab10-grupo-a
if not exist evidencias mkdir evidencias
docker network inspect lab10-a_labnet --format "{{range .Containers}}{{.Name}} {{end}}" > evidencias\t1-enderecos.txt
type evidencias\t1-enderecos.txt
  1. Node-RED: importe o nodered/flows-lab10.json do repositório do Lab 09, chame a aba de Lab 10 e troque lab09 por lab10 nos quatro nós de configuração (Modbus TCP, Modbus RTU/TCP, S7 e OPC-UA), nos tópicos MQTT e no caminho do SQLite (/data/sqlite/lab10.sqlite). Use Ctrl+F para achar o que sobrou. Deploy e confira o painel em http://localhost/lab10-x/dashboard/lab10.

1.2 Drivers do FUXA​

Abra o editor do FUXA (http://localhost/fuxa/lab10-x/editor) e entre com o usuário do grupo. No FUXA, só o MQTT vem instalado: Modbus e OPC-UA são plugins, baixados do npm na primeira vez. Na engrenagem (Setup) ▸ Plugins, instale:

PluginProtocolo
modbus-serialModbus TCP e RTU
node-opcuaOPC-UA (o maior: leva cerca de 1 min)

Instale a versão que a tela de plugins mostra: é o próprio FUXA que a define (no FUXA 1.3.5, modbus-serial 8.0.19 e node-opcua 2.149.0).

Os plugins ficam na pasta fuxa/lab10-x/pkg/ do LAB IoT: sobrevivem a um docker compose down.

Evidência: evidencias/t1-plugins.png, a tela de plugins com os dois instalados.

📂 lab10-grupo-x/
  • ├── 📂camara-sim
    • └── 📄.env👈 Criar Aqui
  • ├── 📂nodered
    • └── 🔧flows-lab10.json👈 Criar Aqui
  • └── 📂evidencias
    • ├── 📄t1-enderecos.txt👈 Criar Aqui
    • └── 📄t1-plugins.png👈 Criar Aqui
git conferir camara-sim/.env nodered/flows-lab10.json evidencias/t1-enderecos.txt evidencias/t1-plugins.png
Ponto de commit · T1 (10 pts) #

Câmara, Node-RED e drivers do FUXA

1. Conferir os arquivos
git conferir camara-sim/.env nodered/flows-lab10.json evidencias/t1-enderecos.txt evidencias/t1-plugins.png
2. Commit T1 e push
git add camara-sim/.env nodered/flows-lab10.json evidencias/t1-enderecos.txt evidencias/t1-plugins.png && git commit -m "T1: Câmara, Node-RED e drivers do FUXA" && git push
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 — Conexões e tags​

No FUXA, uma conexão é um equipamento, e uma tag é uma variável dele. Telas, alarmes, histórico e scripts só enxergam tags. Em Setup ▸ Connections, o botão + cria uma conexão; o ícone de corrente 🔗 de cada conexão abre a lista de tags, onde o + cria uma tag. A coluna Value mostra o valor ao vivo: use-a para conferir cada tag.

Crie as três conexões, todas com Polling 1 sec:

NameTypeEndereçoOutros campos
Camara OPC-UAOPCUAopc.tcp://lab10-x-camara:4840/Without Security
Camara ModbusModbusTCPSlave IP and Port lab10-x-camara:502Connection options TcpPort, Slave ID 1
Broker MQTTMQTTclientmqtt://mosquitto:1883Without Security

São os mesmos endereços dos nós de configuração do Node-RED (Lab 08, seção 1.3): o FUXA está na mesma rede.

2.1 OPC-UA: o servidor diz o que tem​

Na lista de tags da Camara OPC-UA, o + abre o navegador do servidor (o browse do Lab 08). Expanda Objects ▸ Camara e marque:

PastaVariáveis
Medicoestemp, umid, sp_efetivo
Atuadoresaquecedor_pwm
Estadoestado, estado_txt, alarme
Comandosmodo, setpoint
Simulacaofalha_dht

Cada tag fica com o NodeId como endereço e o tipo que o servidor declara. É o caminho mais simples: nada de mapa de registradores.

O FUXA não avisa quando a escrita OPC-UA falha

O servidor recusa uma escrita com tipo errado (BadTypeMismatch, Lab 08), mas o FUXA não mostra esse erro: o valor simplesmente não muda. Mantenha o tipo que o navegador trouxe.

2.2 Modbus TCP: endereço base 1 e divisor​

Na Camara Modbus, crie as tags à mão, com o mapa do Lab 09. Atenção: no FUXA, o campo Address offset vai de 1 a 65536. O registrador 0 do mapa é o endereço 1 no FUXA, o IR12 é o 13, e assim por diante. O Divisor faz o papel da function "÷10" do Lab 08 (÷ na leitura, × na escrita).

TagnameRegisterAddress offsetTypeDivisorNo Lab 09
IR0 temp x10Input Registers1Int1610r[0] / 10
IR12 temp floatInput Registers13Float32f32(12)
HR1 modoHolding Registers2UInt16HR1

IR0 temp x10 e IR12 temp float devem mostrar a mesma temperatura. Se não mostrarem, o endereço está deslocado de um.

2.3 MQTT: uma chave do JSON​

Na Broker MQTT, o + abre o assinante de tópicos. Em Topic path, coloque elt85b/lab10/grupo-x/camara/telemetria, escolha json, clique Subscribe e marque a chave temp (nome telemetria temp). A chave vira uma tag com o tópico como endereço.

Evidências: evidencias/t2-conexoes.png (Setup ▸ Connections com as três conexões em verde) e o projeto exportado em fuxa/projeto-lab10.json.

Preveja antes de rodar

P1: um colega configurou IR12 temp float com Address offset 12, em vez de 13. Quais registradores da câmara o FUXA lê nesse caso? Olhe o mapa do Lab 09: o que é o IR11? Que tipo de número aparece: próximo da temperatura, enorme ou minúsculo? E se ele tivesse escolhido Float32MLE (ordem de palavras trocada, a P1 do Lab 09) com o endereço certo? Teste os dois.

📂 lab10-grupo-x/
  • ├── 📂fuxa
    • └── 🔧projeto-lab10.json👈 Criar Aqui
  • └── 📂evidencias
    • └── 📄t2-conexoes.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t2-conexoes.png
Ponto de commit · T2 (20 pts) #

Conexões e tags

1. Conferir os arquivos
git conferir fuxa/projeto-lab10.json evidencias/t2-conexoes.png
2. Commit T2 e push
git add fuxa/projeto-lab10.json evidencias/t2-conexoes.png && git commit -m "T2: Conexões e tags" && 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 — Sinótico da câmara​

Um sinótico mostra o processo, e não uma lista de números: o operador entende o estado da câmara num relance e age sem procurar.

3.1 Como um widget se liga a uma tag​

No editor, crie a tela Camara (painel Views ▸ +). Desenhe com as ferramentas de General e Controls. Com o objeto selecionado, Property (ou duplo clique) abre a ligação:

  • Tag: a variável que o widget mostra ou que dirige a animação;
  • Ranges: faixas de valor → cor (formas, botões) ou unidade e casas (valores);
  • Events: o que acontece no clique (Click ▸ Set Value).

3.2 O que a tela precisa ter​

ElementoFerramentaTagConfiguração
Corpo da câmararetângulo (General)estadoRanges: 0 cinza · 1 laranja · 2 azul · 3 verde · 4 vermelho
T, UR, estadoValuetemp, umid, estado_txtunidade °C / %, 1 casa
AquecedorProgress (vertical)aquecedor_pwm0 a 100
SetpointInputsetpoint (OPC-UA)numérico, mín. 20, máx. 55
Botões ON/OFF, PI interno, PI Node-REDButtonmodo (OPC-UA)Click ▸ Set Value 1, 2, 0; Ranges: o botão do modo atual fica azul
Falha do DHT22Buttonfalha_dhtClick ▸ Set Value 1 / outro botão 0
Temperatura por protocolo3 × Valuetemp, IR12 temp float, telemetria tempa mesma câmara por três portas (Lab 08)
Botões que "ficam acesos"

Quando o valor sai de todas as faixas de um botão, o FUXA não volta à cor original: ele mantém a última cor aplicada. Por isso, cada botão de modo precisa de uma faixa para cada valor possível, 0, 1 e 2 (a do próprio modo azul, as outras brancas).

Em Setup ▸ Layout, defina a tela inicial (Start Camara) e mostre os alarmes no cabeçalho (o sino com o contador, para a T4).

Abra o runtime (http://localhost/fuxa/lab10-x/) e teste: mude o setpoint e troque o modo. Os botões acompanham o modo mesmo quando outro programa o muda: escreva o modo pelo dashboard do Node-RED (Lab 09) e veja o FUXA acompanhar.

Evidência: evidencias/t3-sinotico.png, com a câmara aquecendo (laranja), e o projeto exportado.

📂 lab10-grupo-x/
  • ├── 📂fuxa
    • └── 🔧projeto-lab10.json👈 Edite Aqui
  • └── 📂evidencias
    • └── 📄t3-sinotico.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t3-sinotico.png
Ponto de commit · T3 (20 pts) #

Sinótico da câmara

1. Conferir os arquivos
git conferir fuxa/projeto-lab10.json evidencias/t3-sinotico.png
2. Commit T3 e push
git add fuxa/projeto-lab10.json evidencias/t3-sinotico.png && git commit -m "T3: Sinótico da câmara" && 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 — Alarmes​

Um alarme é uma condição anormal que exige ação do operador: tem prioridade, texto, instante de entrada e de saída e reconhecimento (ack). Em Setup ▸ Alarms ▸ +, escolha a tag e preencha o nível, a faixa min–max, o texto e o modo de reconhecimento.

AlarmeTagNívelFaixaTextoAck
TemperaturatempHigh45–200Temperatura alta (>= 45 °C)Floating
Sensor DHT22alarmeHigh High2–3Falha do sensor DHT22Ack by active Alarm allowed
  • O alarme da câmara é um campo de bits (Lab 09): bit 0 = sobretemperatura, bit 1 = sensor. Valor 2 ou 3 significa "sensor com falha".
  • Em ambos, Time in Min-Max range 1 s e Check interval 1 s.
  • Ack mode: Floating some sozinho quando a condição acaba; Ack by active Alarm allowed fica na lista até o operador reconhecer.

Teste:

  1. Modo ON/OFF e setpoint 50 °C: quando T passa de 45 °C, entra "Temperatura alta".
  2. Clique Falha do DHT22: a câmara vai para ALARME (vermelho), e entra "Falha do sensor". Tire a falha.
  3. No sino do cabeçalho, abra a lista e reconheça (✔) o alarme do sensor.

Evidência: evidencias/t4-alarmes.png com a lista de alarmes aberta.

Preveja antes de rodar

P2: com o setpoint em 45 °C e o PI interno, a temperatura oscila ±0,1 °C em torno de 45 °C. O que acontece com o alarme "Temperatura alta" (Floating, 1 s na faixa)? Ele entra e sai quantas vezes por minuto? Por que normas de alarme (ISA-18.2) pedem uma banda morta no limite? Como você a imitaria no FUXA, que só tem faixas min–max?

📂 lab10-grupo-x/
  • ├── 📂fuxa
    • └── 🔧projeto-lab10.json👈 Edite Aqui
  • └── 📂evidencias
    • └── 📄t4-alarmes.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t4-alarmes.png
Ponto de commit · T4 (15 pts) #

Alarmes

1. Conferir os arquivos
git conferir fuxa/projeto-lab10.json evidencias/t4-alarmes.png
2. Commit T4 e push
git add fuxa/projeto-lab10.json evidencias/t4-alarmes.png && git commit -m "T4: Alarmes" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

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


Parte 5 — Histórico e tendência​

No Lab 09, o histórico foi programado: tabela, INSERT e consultas no SQLite. O FUXA tem um historiador próprio (o DAQ), que só precisa ser ligado em cada tag.

  1. Na lista de tags, o menu ⋮ ▸ Tag options de cada tag tem Registration Enabled (grava a tag), Save if changed (grava quando o valor muda) e Save value interval (grava também a cada N s, mesmo parado; use 60). Ligue o registro em temp, sp_efetivo e aquecedor_pwm.
  2. Setup ▸ Line charts ▸ +: gráfico Camara com temp (vermelho), sp_efetivo (laranja) e aquecedor_pwm (cinza, no eixo Y2, em %).
  3. Crie a tela Tendencia com um Chart: Chart to show Camara, Show mode Realtime, Max minutes 15 e Load history ligado. Acrescente-a ao menu (Setup ▸ Layout). O Chart herda a cor de preenchimento selecionada no editor: se ela estiver preta, o fundo fica preto e os eixos somem. Escolha um preenchimento claro antes de desenhar, ou mude a cor de fundo nas propriedades do gráfico.

Faça um degrau (35 → 40 °C, PI interno) e veja a resposta na tendência.

Evidência: evidencias/t5-tendencia.png, com o degrau visível.

Preveja antes de rodar

P3: na tendência, quando você muda o setpoint de 35 para 40 °C, a linha do SP aparece como uma rampa inclinada, e não como um degrau. Por quê? (Dica: quando o DAQ gravou o SP, e como o gráfico liga dois pontos?) Compare com o gráfico do Lab 09, alimentado a cada conjunto do OPC-UA.

📂 lab10-grupo-x/
  • ├── 📂fuxa
    • └── 🔧projeto-lab10.json👈 Edite Aqui
  • └── 📂evidencias
    • └── 📄t5-tendencia.png👈 Criar Aqui
git conferir fuxa/projeto-lab10.json evidencias/t5-tendencia.png
Ponto de commit · T5 (15 pts) #

Histórico e tendência

1. Conferir os arquivos
git conferir fuxa/projeto-lab10.json evidencias/t5-tendencia.png
2. Commit T5 e push
git add fuxa/projeto-lab10.json evidencias/t5-tendencia.png && git commit -m "T5: Histórico e tendência" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

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


Projeto integrador — FUXA + Node-RED: quem controla e quem vigia​

No Lab 09, o PI externo era ligado por um switch no dashboard do próprio Node-RED, e a P4 mostrou o problema: se o Node-RED cai com o aquecedor ligado, ninguém desliga. Agora as responsabilidades se separam:

QuemFaz
Câmaraexecuta: obedece ao modo (0 MANUAL, 1 ON/OFF, 2 PI interno)
Node-REDcontrola: roda o PI sempre que a câmara está em modo 0 e publica um sinal de vida
FUXAopera e vigia: o operador escolhe o modo; um script devolve a câmara ao modo 2 se o Node-RED parar

Requisitos​

  1. Node-RED: o PI obedece ao modo. Na function "PI" do Lab 09, troque o começo (a parte que olha o pi_ativo do switch):

    function: PI — início (o resto é igual ao Lab 09)
    // Lab 10: atua sempre que a câmara está em modo 0 (MANUAL), não importa quem escolheu
    // o modo (FUXA, dashboard, Modbus...). Fora do modo 0, fica parado.
    const p = msg.payload;
    if (p.modo !== 0) {
    context.set("I", 0);
    context.set("t0", null);
    node.status({
    fill: "grey",
    shape: "ring",
    text: `parado (modo ${p.modo})`,
    });
    return [null, null];
    }
  2. Node-RED: sinal de vida. Ligue a 2ª saída do PI (diagnóstico) a esta function e a um mqtt out elt85b/lab10/grupo-x/scada/pi:

    function: estado do PI -> SCADA
    // Estado do PI -> FUXA. O 'seq' é o sinal de vida que o supervisor do FUXA vigia.
    const seq = (context.get("seq") || 0) + 1;
    context.set("seq", seq);
    const p = msg.payload;
    msg.payload = {
    seq,
    e: Number(p.e.toFixed(3)),
    I: Number(p.I.toFixed(2)),
    aq: p.aq,
    ts: Date.now(),
    };
    return msg;
  3. FUXA: tags do PI. Na Broker MQTT, tópico elt85b/lab10/grupo-x/scada/pi, json, chaves seq (nome pi seq), e (pi erro) e aq (pi aquecedor). Mostre pi erro e pi aquecedor no sinótico, ao lado dos botões de modo.

  4. FUXA: supervisor. Em Setup ▸ Scripts ▸ +: nome supervisor_pi_externo, Execute mode Server, e em Script scheduling Loop with interval de 2 s:

    script: supervisor_pi_externo
    // Supervisor do PI externo: roda no SERVIDOR do FUXA a cada 2 s.
    // Se a câmara está em MANUAL (modo 0) e o Node-RED parou de publicar .../scada/pi
    // (o seq não muda há mais de 10 s), volta ao PI interno (modo 2) pelo Modbus.
    const LIMITE_S = 10;
    // tags pelo NOME (tag, conexão): os nomes têm de ser exatamente os da T2
    const MODO = $getTagId("modo", "Camara OPC-UA"); // leitura do modo
    const MODO_MB = $getTagId("HR1 modo", "Camara Modbus"); // escrita do fallback
    const SEQ = $getTagId("pi seq", "Broker MQTT"); // sinal de vida do Node-RED

    const modo = Number($getTag(MODO));
    const seq = $getTag(SEQ);
    const agora = Date.now();
    const wd =
    globalThis.wd ||
    (globalThis.wd = { seq: seq, desde: agora, modo: modo, disparou: false });
    // recomeça a contar quando chega seq novo OU quando o operador acabou de escolher o modo 0
    if (seq !== wd.seq || (modo === 0 && wd.modo !== 0)) {
    wd.seq = seq;
    wd.desde = agora;
    wd.disparou = false;
    }
    wd.modo = modo;
    const idade = Math.round((agora - wd.desde) / 1000);
    if (modo === 0 && idade > LIMITE_S && !wd.disparou) {
    wd.disparou = true; // uma vez só (a leitura do modo demora um ciclo)
    $setTag(MODO_MB, 2); // fallback: PI interno
    console.log(
    "supervisor: PI externo sem resposta ha " + idade + " s -> modo 2",
    );
    }

    O fallback escreve pelo Modbus de propósito: no log da câmara, opcua: modo = … é o operador e modbus: modo = 2 é o supervisor.

  5. Experimento (setpoint 40 °C):

    1. No FUXA, clique PI Node-RED: pi erro e pi aquecedor mudam a cada ~2 s.

    2. Pare o controlador e cronometre: em 10 a 14 s, a câmara volta ao PI interno (o botão "PI interno" acende).

      Terminal (cmd)
      docker stop lab10-x-nodered
    3. docker start lab10-x-nodered, espere o Node-RED subir e clique PI Node-RED de novo.

  6. Evidências:

    • evidencias/t6-fallback.png: o sinótico depois do fallback;
    • evidencias/t6-log.txt: as escritas de modo vistas pela câmara;

1. Log das escritas de modo:

Terminal (cmd), na raiz do repositório
docker logs lab10-a-camara 2>&1 | findstr /l /c:"modo =" > evidencias\t6-log.txt
type evidencias\t6-log.txt
evidencias/t6-log.txt (exemplo)
[14:25:49] [cmd] opcua: modo = 0
[14:26:32] [cmd] modbus: modo = 2
[14:26:57] [cmd] opcua: modo = 0
  • nodered/flows-lab10.json e fuxa/projeto-lab10.json exportados de novo;
  • no README.md, as respostas de P1 a P4.
Preveja antes de rodar

P4: (a) o que acontece se o operador clicar ON/OFF no FUXA enquanto o PI externo está agindo? (b) E se o FUXA cair com a câmara em modo 0 e, depois, o Node-RED também cair? (c) Com base na P4 do Lab 09: o supervisor no FUXA substitui um watchdog dentro do equipamento? Onde cada proteção deve ficar?

📂 lab10-grupo-x/
  • ├── 📂nodered
    • └── 🔧flows-lab10.json👈 Edite Aqui
  • ├── 📂fuxa
    • └── 🔧projeto-lab10.json👈 Edite Aqui
  • ├── 📂evidencias
    • ├── 📄t6-fallback.png👈 Criar Aqui
    • └── 📄t6-log.txt👈 Criar Aqui
  • └── 📝README.md👈 Edite Aqui
git conferir nodered/flows-lab10.json fuxa/projeto-lab10.json evidencias/t6-fallback.png evidencias/t6-log.txt README.md
Ponto de commit · T6 (20 pts) #

FUXA + Node-RED: quem controla e quem vigia

1. Conferir os arquivos
git conferir nodered/flows-lab10.json fuxa/projeto-lab10.json evidencias/t6-fallback.png evidencias/t6-log.txt README.md
2. Commit T6 e push
git add nodered/flows-lab10.json fuxa/projeto-lab10.json evidencias/t6-fallback.png evidencias/t6-log.txt README.md && git commit -m "T6: FUXA + Node-RED: quem controla e quem vigia" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

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


Referência rápida​

ProblemaO que fazer
Conexão OPC-UA ou Modbus vermelha logo de inícioo plugin (node-opcua, modbus-serial) não foi instalado (T1)
Conexão vermelha com o plugin instaladoo endereço é o nome na rede (lab10-x-camara), e não localhost; confira com o docker network inspect da T1
IR0 temp x10 e IR12 temp float diferentesAddress offset deslocado de um: no FUXA, o registrador 0 é o endereço 1 (P1)
Escrevi no setpoint e nada mudoutipo da tag OPC-UA trocado; mantenha o que o navegador trouxe
Botão de modo continua azulfalta uma faixa para cada valor do modo (0, 1, 2)
O supervisor não faz nadaos nomes no $getTagId têm de ser idênticos aos das tags e das conexões; o script está em modo Server e com Loop
O editor do FUXA pede loginuse o usuário e a senha do grupo (credenciais.txt)

Logout do seu ambiente dev, git e gh​

Ao terminar, pare os containers:

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

Para o git "esquecer" suas informações salvas:

git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
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.