Guia Prático de Automação Industrial

Integração de Python, MQTT e HTML com PLCs industriais - Passo a Passo

Introdução

Este guia demonstra como integrar tecnologias modernas (Python, MQTT, HTML) com PLCs industriais tradicionais. Você aprenderá desde a configuração básica até a criação de dashboards completos.

Pré-requisitos:
  • Conhecimento básico de programação Python
  • Acesso a um PLC para testes (físico ou simulador)
  • Computador com Python 3.6+ instalado
  • Conexão de rede com o PLC

Conexão com PLCs

Aprenda a conectar e interagir com os principais modelos de PLCs usando Python.

1 Allen-Bradley (Rockwell)

Para conectar com PLCs Rockwell (ControlLogix, CompactLogix), utilizamos a biblioteca pycomm3.

# Instale a biblioteca primeiro:
# pip install pycomm3

from pycomm3 import LogixDriver

# 1. Configure o endereço IP do seu PLC
with LogixDriver('192.168.1.10') as plc:
    # 2. Leitura de tags - substitua pelo nome da tag do seu projeto
    temperatura = plc.read('TANQUE_1.TEMPERATURA')
    print(f"Temperatura atual: {temperatura.value}°C")
    
    # 3. Escrita de tags - exemplo para ativar uma saída
    plc.write('TANQUE_1.VALVULA', True)
    print("Válvula ativada")
Dicas importantes:
  • Verifique o endereço IP do PLC no RSLogix/Studio 5000
  • Os nomes das tags devem ser exatamente iguais ao projeto
  • Para listar todas as tags disponíveis: tags = plc.get_tag_list()

2 Siemens (S7-1200/1500)

Para PLCs Siemens, usamos a biblioteca python-snap7 que se comunica via protocolo proprietário S7.

# Instalação necessária:
# pip install python-snap7

from snap7 import client
from snap7.util import get_real, get_int

# 1. Crie o cliente e conecte
plc = client.Client()
plc.connect('192.168.1.20', 0, 1)  # IP, rack, slot

# 2. Leitura de DB (Data Block)
# Exemplo: DB1, 4 bytes a partir do offset 0
db_data = plc.db_read(1, 0, 4)

# 3. Converter bytes para valores reais
# Primeiros 2 bytes (REAL)
temperatura = get_real(db_data, 0)
# Bytes 3-4 (INT)
pressao = get_int(db_data, 2)

print(f"Temperatura: {temperatura:.2f}°C, Pressão: {pressao}")

# 4. Não esqueça de desconectar
plc.disconnect()
Atenção: Você precisará configurar as permissões de comunicação no TIA Portal:
  1. Acesse as propriedades do PLC
  2. Vá em "Protection & Security"
  3. Habilite "Permit access with PUT/GET communication"

Comunicação MQTT

MQTT é o protocolo ideal para IoT industrial, permitindo comunicação leve e eficiente entre dispositivos.

1 Configurando o Broker Mosquitto

Passo a passo para instalar e configurar um broker MQTT em Linux:

# 1. Instalação no Ubuntu/Debian
sudo apt update
sudo apt install -y mosquitto mosquitto-clients

# 2. Configuração básica (edite o arquivo)
sudo nano /etc/mosquitto/mosquitto.conf

# Adicione estas linhas:
allow_anonymous true  # Permite conexões sem autenticação
listener 1883        # Porta padrão MQTT
persistence true     # Mantém mensagens entre reinícios

# 3. Reinicie o serviço
sudo systemctl restart mosquitto

# 4. Teste o broker (em outro terminal)
mosquitto_sub -t "teste"  # Subscreve no tópico "teste"
# Em outro terminal:
mosquitto_pub -t "teste" -m "Olá MQTT"
Para produção:
  • Configure usuário/senha com mosquitto_passwd
  • Habilite SSL/TLS para comunicação segura
  • Considere usar autenticação por certificado

2 Publicando Dados do PLC via MQTT

Exemplo completo para ler dados do PLC e publicar no broker MQTT:

# pip install paho-mqtt pycomm3

import paho.mqtt.client as mqtt
from pycomm3 import LogixDriver
import json
import time

# 1. Configuração MQTT
broker = "seu.broker.com"
port = 1883
topic = "fabrica/linha1/plc1"

# 2. Callback quando conecta
def on_connect(client, userdata, flags, rc):
    print(f"Conectado ao broker com código {rc}")

# 3. Crie o cliente
client = mqtt.Client("PLC_Publisher")
client.on_connect = on_connect
client.connect(broker, port)
client.loop_start()  # Thread para manter conexão

# 4. Conexão com PLC
plc = LogixDriver('192.168.1.10')

try:
    while True:
        # 5. Leitura das tags
        dados = {
            "temperatura": plc.read('TANQUE_1.TEMP').value,
            "nivel": plc.read('TANQUE_1.NIVEL').value,
            "valvula": plc.read('TANQUE_1.VALV').value,
            "timestamp": time.time()
        }
        
        # 6. Publica como JSON
        client.publish(topic, json.dumps(dados))
        print(f"Publicado: {dados}")
        
        # 7. Intervalo de publicação
        time.sleep(5)

except KeyboardInterrupt:
    print("Encerrando...")
    client.loop_stop()
    plc.close()
Melhores práticas para tópicos MQTT:
  • Use hierarquia clara: local/equipamento/tipo
  • Evite espaços e caracteres especiais
  • Para dados estruturados, use JSON
  • Defina QoS apropriado (0, 1 ou 2)

Dashboard Industrial

Crie uma interface web moderna para monitorar seus PLCs em tempo real.

1 Dashboard HTML/JS Completo

Interface completa com Bootstrap, Chart.js e Paho MQTT:

<!DOCTYPE html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Monitor Industrial</title>
    <!-- Bootstrap 5 -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <!-- Chart.js -->
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <!-- Paho MQTT -->
    <script src="https://cdnjs.cloudflare.com/ajax/libs/paho-mqtt/1.0.1/mqttws31.min.js"></script>
    <style>
        .card-data {
            transition: all 0.3s;
        }
        .card-data:hover {
            transform: translateY(-5px);
            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
        }
        .value-display {
            font-size: 2.5rem;
            font-weight: bold;
        }
    </style>
</head>
<body>
    <div class="container-fluid py-4">
        <h1 class="text-center mb-4">Monitoramento Industrial</h1>
        
        <div class="row">
            <!-- Temperatura -->
            <div class="col-md-4 mb-4">
                <div class="card card-data h-100">
                    <div class="card-header bg-danger text-white">
                        <h5 class="mb-0">Temperatura do Tanque</h5>
                    </div>
                    <div class="card-body text-center">
                        <div class="value-display text-danger" id="temp-value">--°C</div>
                        <canvas id="temp-chart" height="150"></canvas>
                    </div>
                </div>
            </div>
            
            <!-- Outros cards similares -->
        </div>
    </div>

    <script>
        // 1. Configuração MQTT
        const client = new Paho.MQTT.Client("seu.broker.com", Number(9001), "dashboardClient");
        
        // 2. Arrays para histórico
        const tempData = {
            values: [],
            timestamps: []
        };
        
        // 3. Conexão ao broker
        client.connect({
            onSuccess: () => {
                console.log("Conectado ao broker");
                client.subscribe("fabrica/#");
            },
            onFailure: (err) => {
                console.error("Falha na conexão:", err);
            }
        });
        
        // 4. Processamento das mensagens
        client.onMessageArrived = (message) => {
            const data = JSON.parse(message.payloadString);
            
            // Atualiza temperatura
            document.getElementById("temp-value").textContent = `${data.temperatura.toFixed(1)}°C`;
            
            // Adiciona ao histórico (mantém últimos 20 valores)
            tempData.values.push(data.temperatura);
            tempData.timestamps.push(new Date().toLocaleTimeString());
            if(tempData.values.length > 20) {
                tempData.values.shift();
                tempData.timestamps.shift();
            }
            
            // Atualiza gráfico
            updateChart();
        };
        
        // 5. Configuração do gráfico
        const tempCtx = document.getElementById('temp-chart').getContext('2d');
        const tempChart = new Chart(tempCtx, {
            type: 'line',
            data: {
                labels: tempData.timestamps,
                datasets: [{
                    label: 'Temperatura °C',
                    data: tempData.values,
                    borderColor: 'rgba(220, 53, 69, 1)',
                    backgroundColor: 'rgba(220, 53, 69, 0.1)',
                    tension: 0.1
                }]
            },
            options: {
                responsive: true,
                plugins: {
                    legend: { display: false }
                },
                scales: {
                    y: { beginAtZero: false }
                }
            }
        });
        
        // 6. Função para atualizar gráfico
        function updateChart() {
            tempChart.data.labels = tempData.timestamps;
            tempChart.data.datasets[0].data = tempData.values;
            tempChart.update();
        }
    </script>
</body>
</html>
Como implementar:
  1. Salve como dashboard.html
  2. Coloque em um servidor web (Apache, Nginx, ou até Python: python -m http.server 8000)
  3. Acesse pelo navegador: http://localhost:8000/dashboard.html
  4. Personalize os tópicos MQTT e variáveis conforme seu projeto

Dicas Avançadas

1 Usando OPC UA como Alternativa

OPC UA é um padrão industrial robusto para comunicação de dados.

# pip install opcua

from opcua import Client
from opcua.ua import VariantType

# 1. Conexão ao servidor OPC UA
url = "opc.tcp://192.168.1.100:4840"
client = Client(url)
client.connect()

try:
    # 2. Navegação no namespace
    root = client.get_root_node()
    objects = client.get_objects_node()
    
    # 3. Acessando nós por caminho
    temp_node = client.get_node("ns=2;s=Linha1/Tanque1/Temperatura")
    print("Temperatura:", temp_node.get_value())
    
    # 4. Escrevendo valores
    setpoint_node = client.get_node("ns=2;s=Linha1/Tanque1/Setpoint")
    setpoint_node.set_value(75.0, VariantType.Double)
    
    # 5. Assinatura para mudanças
    class SubHandler:
        def datachange_notification(self, node, val, data):
            print(f"Dado alterado: {node} = {val}")

    handler = SubHandler()
    sub = client.create_subscription(500, handler)
    handle = sub.subscribe_data_change(temp_node)

finally:
    # 6. Desconectar
    client.disconnect()
Vantagens do OPC UA:
  • Padrão industrial consolidado
  • Segurança integrada (criptografia, autenticação)
  • Modelo de informação rico
  • Independente de fabricante

2 Armazenamento com InfluxDB

Banco de dados temporal ideal para dados industriais.

# pip install influxdb

from influxdb import InfluxDBClient
from datetime import datetime

# 1. Conexão ao banco
client = InfluxDBClient(host='localhost', port=8086)
client.switch_database('dados_industriais')

# 2. Estrutura dos dados
json_body = [
    {
        "measurement": "temperatura",
        "tags": {
            "linha": "1",
            "equipamento": "tanque1",
            "plc": "S7-1200"
        },
        "time": datetime.utcnow().isoformat(),
        "fields": {
            "valor": 45.2,
            "setpoint": 50.0,
            "status": "normal"
        }
    }
]

# 3. Escrita no banco
client.write_points(json_body)

# 4. Consulta de dados
result = client.query('''
    SELECT mean("valor") 
    FROM "temperatura" 
    WHERE "equipamento"='tanque1' 
    AND time > now() - 1h 
    GROUP BY time(5m)
''')

# 5. Processamento dos resultados
for point in result.get_points():
    print(f"{point['time']}: {point['mean']:.2f}°C")
Configuração InfluxDB:
  1. Baixe e instale em influxdata.com
  2. Crie o banco: CREATE DATABASE dados_industriais
  3. Configure retenção: CREATE RETENTION POLICY "1_year" ON "dados_industriais" DURATION 52w REPLICATION 1

3 Boas Práticas de Segurança

Protegendo sua Infraestrutura Industrial
  • Segmentação de Rede: Isole a rede industrial da rede corporativa
  • Autenticação Forte: Use certificados digitais ou autenticação multifator
  • Atualizações: Mantenha todos os sistemas atualizados
  • Backups: Faça backups regulares dos programas dos PLCs
  • Monitoramento: Implemente soluções para detectar anomalias
# Exemplo: MQTT com TLS e autenticação

import paho.mqtt.client as mqtt
import ssl

# 1. Configure o cliente
client = mqtt.Client("secure_client")
client.username_pw_set("usuario", "senhaF0rte!")

# 2. Configure TLS
client.tls_set(
    ca_certs="ca.crt",
    certfile="client.crt",
    keyfile="client.key",
    cert_reqs=ssl.CERT_REQUIRED,
    tls_version=ssl.PROTOCOL_TLSv1_2
)

# 3. Conecte com segurança
client.connect("broker.seguro.com", 8883, 60)
client.loop_start()

Dicas e Curiosidades sobre Automação Industrial

🔧 O que é Automação Industrial?

A automação industrial é o uso de tecnologias como PLCs, sensores, redes industriais e softwares para controlar e monitorar processos industriais com o objetivo de aumentar a produtividade, reduzir custos e melhorar a segurança.

🤖 Aplicações da Inteligência Artificial na Indústria

  • Manutenção Preditiva: IA analisa dados de sensores para prever falhas antes que ocorram.
  • Controle de Qualidade: Visão computacional com IA identifica defeitos em tempo real.
  • Otimização de Processos: Algoritmos otimizam consumo energético e produtividade.
  • Robôs Colaborativos: Trabalham lado a lado com humanos de forma segura e eficiente.

📈 Impactos da IA para os Profissionais de Automação

Com a ascensão da IA, o profissional de automação precisa dominar não apenas CLPs e redes industriais, mas também ferramentas de dados, algoritmos e análise de comportamento dos sistemas. A IA não substitui — ela complementa.

Áreas em destaque incluem:

  • Integração entre IA e PLCs
  • Programação Python voltada à indústria
  • Machine Learning aplicado à produção
  • Dashboards inteligentes com IA embarcada

💡 Curiosidade: IA + CLP

Sabia que é possível integrar um modelo de IA com um PLC usando MQTT ou OPC UA? Assim, decisões podem ser tomadas em tempo real com base em padrões aprendidos pela IA.