Entrar ou criar conta

ULC Lab · implementação reproduzível

Laboratório: Supervisão Industrial Aberta com OpenPLC, Node-RED e Grafana

Você terá um sistema SCADA aberto funcional, com um OpenPLC simulando um processo, dados trafegando via Modbus TCP para o Node-RED, e painéis de monitoramento no Grafana. Tempo estimado: 2 a 3 horas.

Supervisão industrial aberta: SCADA com OpenPLC e Grafana
Ligado ao treinamento Supervisão industrial aberta: SCADA com OpenPLC e Grafana
ULC-LAB-INDU-0004 · Status de validaçãoNão validado pela Upnetix: roteiro derivado da documentação oficial, para você executar e validar
Duração estimada
120 min
Passos
11
Validações
4
Versões da documentação consultada
OpenPLC Runtime a versão estável atual · Node-RED a versão estável atual · Grafana OSS a versão estável atual · Docker a versão estável atual
Objetivo

Este laboratório ensina como integrar o OpenPLC rodando um programa ladder simples, o Node-RED como middleware para leitura via Modbus TCP, e o Grafana para visualização em tempo real. O objetivo é demonstrar, em ambiente controlado, como montar uma cadeia completa de supervisão industrial aberta, usando apenas software livre e padrões abertos.

Topologia

O OpenPLC rodará em uma VM (192.168.56.10), expondo variáveis por Modbus TCP. O Node-RED, em outra VM (192.168.56.20), fará polling dessas variáveis e exporá via API HTTP. O Grafana, em uma terceira VM (192.168.56.30), consumirá a API do Node-RED para exibir dashboards. Todos os hosts estão na mesma rede privada.

      +----------------+
      |   Grafana      |
      |192.168.56.30   |
      +-------+--------+
              |
              |
      +-------v--------+
      |   Node-RED     |
      |192.168.56.20   |
      +-------+--------+
              |
              |
      +-------v--------+
      |   OpenPLC      |
      |192.168.56.10   |
      +----------------+

Equipamentos e software

ItemRequisito, licença ou versão
VM ou PC para OpenPLC1 vCPU, 1GB RAM, Ubuntu 22.04 ou superior
VM ou PC para Node-RED1 vCPU, 1GB RAM, Ubuntu 22.04 ou superior
VM ou PC para Grafana1 vCPU, 1GB RAM, Ubuntu 22.04 ou superior
OpenPLC RuntimeGPLv3 · a versão estável atual
Node-REDApache 2.0 · a versão estável atual
Grafana OSSAGPLv3 · a versão estável atual
DockerApache 2.0 · a versão estável atual

Roteiro

  1. Preparar as VMs

    Crie três VMs Linux na mesma rede privada (exemplo: 192.168.56.0/24). Isso isola os serviços e simula um ambiente industrial real.

    O que você deve ver: VMs acessíveis via SSH, ping entre elas funcionando.

  2. Instalar o OpenPLC Runtime

    No host 192.168.56.10, instale o OpenPLC Runtime. O OpenPLC simula o CLP e expõe variáveis via Modbus TCP.

    sudo apt update && sudo apt install git python3 python3-pip
    cd ~
    git clone https://github.com/thiagoralves/OpenPLC_v3.git
    cd OpenPLC_v3
    sudo ./install.sh

    O que você deve ver: OpenPLC instalado, serviço disponível em http://192.168.56.10:8080

  3. Configurar e rodar um programa ladder no OpenPLC

    Faça login na interface web do OpenPLC e carregue um programa ladder de teste. Isso permitirá simular variáveis digitais e analógicas.

    Acesse http://192.168.56.10:8080, usuário padrão: openplc, senha: openplc. Carregue o exemplo 'Simple Ladder'.

    O que você deve ver: Programa ladder rodando, status 'Running' na interface.

  4. Habilitar o servidor Modbus TCP do OpenPLC

    O OpenPLC expõe as variáveis via Modbus TCP por padrão. Confirme a porta (502) e IP.

    Consulte a documentação em www.openplcproject.com/docs para detalhes de configuração.

    O que você deve ver: Porta 502 aberta, serviço escutando.

  5. Instalar o Node-RED

    No host 192.168.56.20, instale o Node-RED. Ele fará o papel de middleware, conectando-se ao OpenPLC via Modbus TCP.

    sudo apt update && sudo apt install -y nodejs npm
    sudo npm install -g --unsafe-perm node-red

    O que você deve ver: Node-RED disponível em http://192.168.56.20:1880

  6. Instalar o node-red-contrib-modbus

    Esse pacote permite ao Node-RED ler e escrever dados via Modbus TCP.

    cd ~/.node-red
    npm install node-red-contrib-modbus

    O que você deve ver: Pacote instalado, novos nodes Modbus disponíveis no editor do Node-RED.

  7. Criar um fluxo no Node-RED para ler variáveis do OpenPLC

    Monte um fluxo: node 'modbus-read' (cliente TCP, IP 192.168.56.10, porta 502) lendo registradores e enviando para um node 'http response'.

    No editor web, arraste um node 'modbus-read', configure IP/porta, e conecte a um node 'http response'. Consulte nodered.org/docs para detalhes.

    O que você deve ver: Fluxo salvo, Node-RED lendo dados do OpenPLC periodicamente.

  8. Testar a API do Node-RED

    Acesse a URL HTTP exposta pelo Node-RED para ver os dados lidos do OpenPLC.

    curl http://192.168.56.20:1880/<endpoint_configurado>

    O que você deve ver: Resposta JSON com valores das variáveis do OpenPLC.

  9. Instalar o Grafana

    No host 192.168.56.30, instale o Grafana OSS. Ele será usado para criar dashboards customizáveis.

    sudo apt-get install -y apt-transport-https software-properties-common wget
    wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
    echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
    sudo apt update
    sudo apt install grafana
    sudo systemctl start grafana-server
    sudo systemctl enable grafana-server

    O que você deve ver: Grafana disponível em http://192.168.56.30:3000

  10. Configurar o Grafana para consumir a API do Node-RED

    No Grafana, crie uma nova fonte de dados do tipo 'JSON API' (plugin open source). Aponte para o endpoint HTTP do Node-RED.

    Consulte grafana.com/docs/plugins/grafana-json-datasource/latest/ para instalar e configurar o plugin.

    O que você deve ver: Fonte de dados conectada, teste de conexão OK.

  11. Criar um dashboard no Grafana

    Adicione um painel para exibir os valores lidos do OpenPLC via Node-RED. Isso permite visualizar o processo em tempo real.

    No Grafana, clique em 'Novo Painel', selecione a fonte de dados JSON API, configure a consulta conforme os dados do Node-RED.

    O que você deve ver: Painel mostrando valores atualizados das variáveis do OpenPLC.

Como saber que funcionou

TesteComandoCritério
Acessar o painel do Grafana e visualizar dados dinâmicosValores mudando conforme o programa ladder do OpenPLC executa.
Testar leitura direta do Node-REDcurl http://192.168.56.20:1880/<endpoint_configurado>JSON retornado com valores coerentes.
Verificar conectividade Modbus TCPsudo netstat -tnlp | grep 502Porta 502 aberta no OpenPLC.
Verificar logs do Node-REDjournalctl -u nodered -fSem erros de conexão Modbus.

Troubleshooting

SintomaCausa provávelCorreção
Grafana não exibe dadosFonte de dados JSON API mal configurada ou Node-RED offlineVerifique se o Node-RED está rodando e revise a URL no Grafana
Node-RED não lê dados do OpenPLCIP ou porta Modbus TCP incorretosConfirme IP/porta no node 'modbus-read' e no OpenPLC
OpenPLC não responde na porta 502Serviço Modbus não iniciado ou firewall bloqueandoReinicie o OpenPLC e libere a porta 502 no firewall
JSON retornado pelo Node-RED vazioConfiguração do node 'modbus-read' incorretaAjuste o endereço/quantidade de registradores lidos

Segurança e hardening

  • Nunca exponha portas 502, 1880 ou 3000 para a internet sem autenticação forte
  • Altere as senhas padrão do OpenPLC e do Grafana
  • Use firewall para restringir acesso entre as VMs
  • Considere rodar cada serviço em containers isolados para maior controle

Checklist final

Referências

  1. Node-RED Documentation · Node-RED (OpenJS Foundation) (nodered.org)
  2. Grafana Documentation · Grafana Labs (grafana.com)
  3. Docker Documentation · Docker, Inc. (docs.docker.com)
Verificação editorial
Publicado
09/09/2026
Última revisão
09/09/2026
Versão do conteúdo
1.0
Referências
3 oficiais
Revisão técnica
redação e revisão por IA, URLs conferidas na publicação
Status
Atual
Encontrou um erro? Escreva para comercial@upnetix.com.br com o endereço da página. A revisão semestral por IA nunca altera comandos ou configurações sem passar pela fila de revisão.