Conectar PLC Siemens con n8n vía OPC-UA: Guía Paso a Paso

Tu PLC Siemens controla la máquina. Lee sensores, ejecuta lógica, mueve actuadores. Hace su trabajo como un reloj suizo. Pero todo lo que sabe se queda dentro de él — atrapado en un ciclo de scan de milisegundos que nunca sale del armario eléctrico.

Mientras tanto, en la oficina quieren saber cuántas piezas se han fabricado hoy. El de calidad necesita registrar temperaturas de proceso en un Excel. El jefe de mantenimiento quiere un aviso en el móvil cuando suba la vibración del motor. Y tú, el que programa el PLC, acabas siendo el mensajero humano entre la máquina y el resto del mundo.

n8n rompe ese cuello de botella. Es una herramienta de automatización de workflows que puede conectarse con cientos de servicios — bases de datos, APIs, Telegram, Google Sheets, ERP, correo electrónico — y orquestar flujos de datos sin escribir apenas código. El problema es que n8n habla HTTP, JSON y APIs REST. Tu PLC Siemens habla Profinet, S7comm y, si lo configuras, OPC-UA.

En esta guía te enseño cómo conectar ambos mundos. Desde la configuración del servidor OPC-UA en TIA Portal hasta el workflow de n8n que lee variables del PLC y las envía donde quieras. Con capturas reales, código que funciona y los errores que te vas a ahorrar porque yo ya los cometí.

Por qué OPC-UA y no cualquier otro protocolo

Antes de meternos en harina, la pregunta obvia: ¿por qué OPC-UA y no Modbus, MQTT o una conexión directa S7?

La respuesta corta: porque OPC-UA es el único protocolo industrial que habla con todo, es seguro y está diseñado para exactamente esto — exponer datos del PLC a sistemas de nivel superior.

Modbus TCP funciona, pero es un protocolo de los años 70 parcheado con TCP/IP. Sin seguridad, sin estructura de datos, sin descubrimiento de nodos. Cada integración es un mapeo manual de registros que hay que documentar en una hoja de cálculo y rezar para que nadie cambie la dirección de un registro sin avisar.

S7comm / snap7 es una librería que habla directamente con el PLC usando el protocolo propietario de Siemens. Funciona, pero Siemens no lo documenta oficialmente, cambia entre versiones de firmware y no tiene cifrado. Es una solución de hacker, no de ingeniero.

MQTT es excelente para IoT, pero necesitas un broker intermedio y programar en el PLC la publicación de mensajes — algo que Siemens soporta de forma nativa solo en los S7-1500 más recientes con firmware 3.0+, y con limitaciones.

OPC-UA es otra historia:

• Estándar abierto — IEC 62541, adoptado por Siemens, Beckhoff, Rockwell, ABB y todos los grandes.
• Seguridad integrada — Certificados X.509, cifrado AES-256, autenticación por usuario/contraseña o certificado.
• Modelo de datos estructurado — No son registros planos. Son nodos con tipo, descripción y jerarquía. Si tu variable se llama Motor1.Velocidad, así la ves en OPC-UA. Sin documentos de mapeo.
• Descubrimiento automático — Un cliente OPC-UA puede explorar el árbol de nodos del servidor y descubrir qué variables hay disponibles. No necesitas saber las direcciones de antemano.
• Nativo en Siemens S7-1500 — Los S7-1500 (y los S7-1200 con firmware reciente) traen un servidor OPC-UA integrado. Solo hay que activarlo y configurar qué exponer.

Para conectar un PLC Siemens con n8n, OPC-UA es la opción profesional. Todo lo demás son atajos que te van a dar problemas en producción.

La arquitectura completa: del PLC al workflow

Antes de tocar TIA Portal, entiende el flujo completo. Así no te pierdes en los detalles sin ver el cuadro general.

┌─────────────────────────────────┐
│         PLC Siemens S7-1500     │
│    Servidor OPC-UA integrado    │
│    (Puerto 4840, red OT)        │
└──────────────┬──────────────────┘
               │ OPC-UA (TCP/4840)
               │
┌──────────────▼──────────────────┐
│      Gateway OPC-UA → HTTP      │
│   (node-opcua o Prosys Gateway) │
│   Servidor intermedio en DMZ    │
└──────────────┬──────────────────┘
               │ HTTP / REST API
               │
┌──────────────▼──────────────────┐
│            n8n                  │
│   Workflow: leer → procesar →   │
│   enviar a Sheets/DB/Telegram   │
└─────────────────────────────────┘

¿Por qué un gateway intermedio? Porque n8n no habla OPC-UA de forma nativa. n8n es una máquina de workflows basada en HTTP, webhooks y APIs. Necesitas un componente que traduzca entre el mundo OPC-UA del PLC y el mundo HTTP de n8n. Ese componente puede ser:

1. Un microservicio Python/Node.js que expone una API REST y por detrás se conecta al PLC vía OPC-UA. Es la opción más flexible.
2. Prosys OPC-UA Gateway — Software comercial que actúa como puente entre OPC-UA y REST/MQTT. Cero código.
3. Apache PLC4X — Librería open source para conectar con PLCs industriales desde Java/Python.
4. Un nodo custom de n8n — Si te atreves, puedes crear un nodo n8n que integre node-opcua directamente.

En esta guía vamos con la opción 1: un microservicio en Node.js con node-opcua, porque es ligero, gratuito, lo puedes hostear en la misma máquina que n8n y te da control total.

Paso 1: Activar OPC-UA en TIA Portal

Abre TIA Portal y carga tu proyecto del S7-1500. Lo que vamos a hacer es activar el servidor OPC-UA integrado del PLC y decidir qué variables se exponen.

Habilitar el servidor OPC-UA

1. En el árbol del proyecto, haz doble clic sobre la CPU (por ejemplo, CPU 1516-3 PN/DP).
2. Ve a Propiedades → General → OPC UA → Servidor.
3. Marca la casilla Activar servidor OPC UA.
4. En Puerto, deja el valor por defecto: 4840.
5. En Seguridad, configura la política según tu entorno:
   • Para pruebas en laboratorio: None (sin cifrado). Solo durante pruebas.
   • Para producción: Basic256Sha256 con modo Sign & Encrypt. No negociable.
6. Si usas autenticación por usuario/contraseña, añade las credenciales en la sección Acceso de usuario.

Exponer variables del PLC

Por defecto, el servidor OPC-UA del S7-1500 no expone nada. Tienes que marcar explícitamente qué bloques de datos (DB) son accesibles.

1. Abre el DB que contiene las variables que quieres leer (por ejemplo, DB_Produccion).
2. En las propiedades del DB, ve a Atributos.
3. Marca la casilla Accesible desde HMI/OPC UA.
4. Si quieres control granular, puedes marcar cada variable individualmente en la columna Accesible desde OPC UA dentro del editor del DB.

Detalle que muchos olvidan: el S7-1500 necesita tener desactivado el Acceso optimizado al bloque si quieres exponer variables con direcciones absolutas. Si usas acceso simbólico (lo recomendado), no hay problema. Ve a las propiedades del DB → Atributos y decide qué modo te conviene.

Compilar y descargar

Compila el proyecto y descárgalo al PLC. El servidor OPC-UA arranca automáticamente con la CPU. Para verificar que funciona, usa un cliente OPC-UA de escritorio — UaExpert (gratuito) o Prosys OPC UA Browser — y conéctate a opc.tcp://[IP_DEL_PLC]:4840.

Si ves el árbol de nodos con tus variables de DB_Produccion, el PLC ya está listo. Si ves un error de conexión, revisa que el firewall del PLC permite OPC-UA (Propiedades CPU → Protección y seguridad → Cortafuegos → Regla para OPC-UA).

Paso 2: Montar el gateway OPC-UA → REST API

Aquí es donde conectamos el mundo industrial con el mundo de las APIs. Vamos a crear un microservicio Node.js que:

1. Se conecta al PLC vía OPC-UA.
2. Lee las variables que le pidas.
3. Expone esos valores a través de endpoints HTTP que n8n puede consumir.

Preparar el entorno

En tu servidor intermedio (puede ser un Linux en la DMZ, una VM, un Docker, o incluso la misma máquina donde corre n8n):

mkdir plc-gateway && cd plc-gateway
npm init -y
npm install node-opcua express dotenv

El código del gateway

Crea un archivo gateway.js:

const { OPCUAClient, AttributeIds, DataType } = require("node-opcua");
const express = require("express");
require("dotenv").config();

const app = express();
app.use(express.json());

const PLC_ENDPOINT = process.env.PLC_ENDPOINT || "opc.tcp://192.168.0.1:4840";
const PORT = process.env.PORT || 3100;

let session = null;

// Conectar al PLC al arrancar
async function conectar() {
  const client = OPCUAClient.create({
    endpointMustExist: false,
    securityMode: 1, // None para pruebas; cambiar en producción
    securityPolicy: "None",
  });

  await client.connect(PLC_ENDPOINT);
  session = await client.createSession();
  console.log(`Conectado a PLC: ${PLC_ENDPOINT}`);
}

// Endpoint: leer una variable individual
app.get("/read/:nodeId", async (req, res) => {
  try {
    const nodeId = decodeURIComponent(req.params.nodeId);
    const dataValue = await session.read({
      nodeId: nodeId,
      attributeId: AttributeIds.Value,
    });

    res.json({
      nodeId: nodeId,
      value: dataValue.value.value,
      dataType: DataType[dataValue.value.dataType],
      timestamp: dataValue.serverTimestamp,
      status: dataValue.statusCode.name,
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Endpoint: leer múltiples variables de golpe
app.post("/read-batch", async (req, res) => {
  try {
    const { nodeIds } = req.body; // ["ns=3;s=...", "ns=3;s=..."]
    const nodesToRead = nodeIds.map((id) => ({
      nodeId: id,
      attributeId: AttributeIds.Value,
    }));

    const results = await session.read(nodesToRead);
    const response = nodeIds.map((id, i) => ({
      nodeId: id,
      value: results[i].value.value,
      dataType: DataType[results[i].value.dataType],
      timestamp: results[i].serverTimestamp,
    }));

    res.json(response);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Endpoint: explorar nodos hijos (útil para descubrir variables)
app.get("/browse/:nodeId?", async (req, res) => {
  try {
    const nodeId = req.params.nodeId
      ? decodeURIComponent(req.params.nodeId)
      : "RootFolder";
    const browseResult = await session.browse(nodeId);

    const nodos = browseResult.references.map((ref) => ({
      displayName: ref.displayName.text,
      nodeId: ref.nodeId.toString(),
      nodeClass: ref.nodeClass,
    }));

    res.json(nodos);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Endpoint: escribir un valor (con precaución)
app.post("/write", async (req, res) => {
  try {
    const { nodeId, value, dataType } = req.body;
    const statusCode = await session.write({
      nodeId: nodeId,
      attributeId: AttributeIds.Value,
      value: {
        value: {
          dataType: DataType[dataType],
          value: value,
        },
      },
    });

    res.json({
      nodeId,
      written: value,
      status: statusCode.name,
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Health check
app.get("/health", (req, res) => {
  res.json({
    status: session ? "connected" : "disconnected",
    plc: PLC_ENDPOINT,
  });
});

// Arrancar
conectar()
  .then(() => {
    app.listen(PORT, () => {
      console.log(`Gateway OPC-UA corriendo en puerto ${PORT}`);
    });
  })
  .catch((err) => {
    console.error("Error al conectar:", err.message);
    process.exit(1);
  });

Y un .env para no hardcodear nada:

PLC_ENDPOINT=opc.tcp://192.168.0.1:4840
PORT=3100

Arrancar y probar

node gateway.js
# → Conectado a PLC: opc.tcp://192.168.0.1:4840
# → Gateway OPC-UA corriendo en puerto 3100

Verifica que todo funciona:

# Leer una variable
curl http://localhost:3100/read/ns%3D3%3Bs%3D%22DB_Produccion%22.PiezasBuenas

# Resultado:
# {"nodeId":"ns=3;s=\"DB_Produccion\".PiezasBuenas","value":1247,"dataType":"Int32","timestamp":"2026-07-21T08:30:00Z","status":"Good"}

# Explorar nodos disponibles
curl http://localhost:3100/browse

Si ves valores con status Good, el gateway está operativo. Si ves BadNodeIdUnknown, revisa los nodeId — en Siemens, los nodos de DB suelen tener el formato ns=3;s="NombreDB".NombreVariable.

Dockerizar el gateway (recomendado)

Para producción, mete el gateway en un contenedor:

FROM node:20-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY gateway.js .env ./
EXPOSE 3100
CMD ["node", "gateway.js"]

docker build -t plc-gateway .
docker run -d --name plc-gateway -p 3100:3100 \
  --restart unless-stopped plc-gateway

Paso 3: Crear el workflow en n8n

Ahora viene la parte divertida. Ya tienes el PLC exponiendo datos y el gateway traduciéndolos a HTTP. n8n entra en juego para orquestar qué hacer con esos datos.

Workflow 1: Registro de producción cada hora en Google Sheets

Este es el caso de uso más básico y uno de los más demandados. Cada hora, n8n lee los contadores del PLC y los guarda en una hoja de cálculo que dirección puede consultar sin pedirte nada.

Nodos del workflow:

1. Schedule Trigger — Se ejecuta cada 60 minutos.
2. HTTP Request — Llama al gateway para leer las variables de producción.
3. Code — Procesa los datos (calcula OEE, piezas/hora, etc.).
4. Google Sheets — Añade una fila con los datos.

Configuración del nodo HTTP Request:

Método: POST
URL: http://plc-gateway:3100/read-batch
Body (JSON):
{
  "nodeIds": [
    "ns=3;s=\"DB_Produccion\".PiezasBuenas",
    "ns=3;s=\"DB_Produccion\".PiezasMalas",
    "ns=3;s=\"DB_Produccion\".TiempoCiclo_ms",
    "ns=3;s=\"DB_Produccion\".EstadoMaquina",
    "ns=3;s=\"DB_Produccion\".HorasMarcha"
  ]
}

Código del nodo Code para calcular métricas:

const datos = $input.first().json;
const piezasBuenas = datos.find(d => d.nodeId.includes("PiezasBuenas")).value;
const piezasMalas = datos.find(d => d.nodeId.includes("PiezasMalas")).value;
const tiempoCiclo = datos.find(d => d.nodeId.includes("TiempoCiclo")).value;
const estado = datos.find(d => d.nodeId.includes("EstadoMaquina")).value;
const horasMarcha = datos.find(d => d.nodeId.includes("HorasMarcha")).value;

const totalPiezas = piezasBuenas + piezasMalas;
const calidad = totalPiezas > 0 ? (piezasBuenas / totalPiezas * 100).toFixed(1) : 0;
const piezasHora = tiempoCiclo > 0 ? Math.round(3600000 / tiempoCiclo) : 0;

return [{
  json: {
    fecha: new Date().toISOString(),
    piezas_buenas: piezasBuenas,
    piezas_malas: piezasMalas,
    calidad_pct: calidad,
    piezas_hora: piezasHora,
    estado_maquina: estado,
    horas_marcha: horasMarcha,
  }
}];

Resultado: una hoja de cálculo que se actualiza sola cada hora con datos de producción reales. Sin intervención humana, sin macros de Excel, sin exportaciones manuales del SCADA.

Workflow 2: Alerta de parada por Telegram

Cuando la máquina para inesperadamente, quieres saberlo al instante — no cuando alguien te llama media hora después.

Nodos del workflow:

1. Schedule Trigger — Cada 30 segundos (polling rápido).
2. HTTP Request — Lee el estado de la máquina.
3. IF — Comprueba si el estado ha cambiado a parada no programada.
4. Telegram — Envía mensaje con los detalles.
5. HTTP Request (secundario) — Lee variables adicionales para contexto (último error, temperatura, etc.).

Configuración del nodo IF:

Condición: {{ $json.value }} == 3
(donde 3 = parada por fallo en tu lógica de PLC)

Mensaje de Telegram:

🔴 PARADA MÁQUINA — Línea 2

Estado: Parada por fallo (código 3)
Hora: {{ $now.format('HH:mm:ss') }}
Último ciclo: {{ $('HTTP Request 2').item.json.value }} ms
Piezas antes de parada: {{ $('HTTP Request 3').item.json.value }}

Revisar en planta.

Mejora: En lugar de polling cada 30 segundos, puedes usar suscripciones OPC-UA en el gateway para que notifique a n8n solo cuando el valor cambie. Añade un endpoint /subscribe al gateway que abra un WebSocket o haga un POST a un webhook de n8n. Así reduces la carga de red y la latencia de notificación baja a menos de un segundo.

Workflow 3: Registro de lotes en la base de datos del ERP

Este workflow detecta cuándo termina un lote de producción (un cambio en el contador de lotes del PLC) y registra todos los datos del lote en la base de datos del ERP, eliminando la entrada manual.

Nodos del workflow:

1. Webhook (o Schedule Trigger) — Detecta fin de lote.
2. HTTP Request — Lee datos de producción: cantidad, rechazos, tiempo total, parámetros de proceso.
3. Code — Estructura los datos en el formato que espera el ERP.
4. PostgreSQL / MySQL — Inserta el registro del lote en la tabla production_orders.
5. Send Email — Notifica al responsable de producción con el resumen del lote.

// Nodo Code: formatear datos para el ERP
const lote = $input.first().json;

return [{
  json: {
    order_number: `LOT-${new Date().toISOString().slice(0,10).replace(/-/g,'')}-${lote.numero_lote}`,
    product_code: lote.codigo_producto,
    qty_good: lote.piezas_buenas,
    qty_reject: lote.piezas_malas,
    start_time: lote.inicio,
    end_time: lote.fin,
    cycle_time_avg: lote.tiempo_ciclo_medio,
    operator_id: lote.operador,
    machine_id: "LINEA-02",
    status: "completed",
  }
}];

Este tipo de integración suele ahorrar entre 30 y 60 minutos diarios de trabajo administrativo en plantas que todavía registran lotes a mano. Y elimina errores de transcripción, que en sectores regulados (alimentación, farmacia, automoción) pueden costar auditorías.

Paso 4: Seguridad — no la dejes para después

Estás conectando un PLC que controla una máquina real con internet. La seguridad no es opcional, es el primer requisito.

Segmentación de red

El PLC vive en la red OT. El gateway y n8n viven en la red IT o en una DMZ. Entre ambas, un firewall con reglas estrictas:

• OT → DMZ: Solo el puerto 4840 (OPC-UA), solo desde la IP del gateway.
• DMZ → IT: Solo los puertos que n8n necesita (API REST del gateway).
• IT → OT: Bloqueado. Completamente.

Nunca expongas el puerto OPC-UA del PLC directamente a la red corporativa ni, por supuesto, a internet.

Autenticación en el gateway

El gateway REST que hemos creado no tiene autenticación. Para pruebas vale, para producción es inaceptable. Añade al menos un API key:

// Middleware de autenticación básica
app.use((req, res, next) => {
  const apiKey = req.headers["x-api-key"];
  if (apiKey !== process.env.API_KEY) {
    return res.status(401).json({ error: "No autorizado" });
  }
  next();
});

Y en n8n, configura el nodo HTTP Request con el header X-API-Key correspondiente. Para entornos críticos, usa certificados TLS mutuos (mTLS) en lugar de API keys.

OPC-UA con cifrado

En TIA Portal, cambia la política de seguridad del servidor OPC-UA de None a Basic256Sha256 con modo Sign & Encrypt. Esto obliga a que la comunicación entre el gateway y el PLC viaje cifrada. El gateway node-opcua soporta este modo; solo necesitas configurar los certificados:

const client = OPCUAClient.create({
  securityMode: 3, // SignAndEncrypt
  securityPolicy: "Basic256Sha256",
  certificateFile: "./certs/client_cert.pem",
  privateKeyFile: "./certs/client_key.pem",
});

Principio de mínimo privilegio

Solo expone en OPC-UA las variables que realmente necesitas leer. Si n8n solo necesita contadores de producción y estado de máquina, no expongas los setpoints de temperatura ni los comandos de marcha/paro. Un error en el workflow no debería poder arrancar una máquina.

Casos de uso reales que ya funcionan

La conexión PLC Siemens + n8n no es un experimento de laboratorio. Hay fábricas que ya la usan en producción. Estos son tres escenarios que he visto implementados con éxito.

Trazabilidad de producción en alimentación

Una planta de procesado cárnico necesitaba registrar cada lote con trazabilidad completa: temperatura de proceso, tiempos, operador, materias primas. Antes lo hacían en papel. Ahora, el PLC S7-1500 de cada línea expone los datos vía OPC-UA, n8n los recoge al finalizar cada lote y los inserta en un sistema de trazabilidad web. El auditor de seguridad alimentaria accede a los registros en tres clics. El operador no toca un papel.

Cuadro de mando de OEE en tiempo real

Una empresa de inyección de plástico tenía 12 máquinas y ningún dato fiable de rendimiento. Conectaron los 12 PLCs (mezcla de S7-1500 y S7-1200) a un gateway OPC-UA centralizado. n8n lee los contadores cada minuto, calcula la disponibilidad, el rendimiento y la calidad (las tres patas del OEE), y vuelca los resultados en un dashboard Grafana que el director de operaciones mira cada mañana. El primer mes descubrieron que una máquina tenía un 22% de microparadas que nadie había detectado porque cada una duraba menos de un minuto.

Alertas predictivas de mantenimiento

Un fabricante de componentes de automoción conectó los datos de vibración y temperatura de los husillos de sus centros de mecanizado (controlados por PLCs Siemens) con n8n. Un workflow lee esas variables cada 5 minutos, las compara con umbrales dinámicos calculados por un modelo Python, y cuando detecta una tendencia al alza envía un aviso al equipo de mantenimiento por Telegram con la predicción de horas restantes hasta fallo. Redujeron las paradas no planificadas un 35% en seis meses.

Errores comunes y cómo evitarlos

Después de varias integraciones PLC-n8n, estos son los tropiezos que se repiten.

Ignorar los nodeId de Siemens

Los nodeId en un S7-1500 tienen un formato específico que cambia según cómo hayas nombrado las cosas en TIA Portal. El patrón habitual es ns=3;s="NombreDB".Variable, con las comillas incluidas. Si tu variable es un array o un struct, la ruta se alarga: ns=3;s="DB_Proceso".Zona[2].Temperatura. Un solo carácter mal puesto y recibes BadNodeIdUnknown. Usa el endpoint /browse del gateway para explorar el árbol y copiar los nodeId exactos.

Polling demasiado agresivo

Leer el PLC cada segundo puede parecer buena idea, pero si tienes 50 variables y un ciclo de lectura de 1 segundo, estás generando 50 lecturas OPC-UA por segundo. El servidor OPC-UA del S7-1500 aguanta — Siemens especifica hasta 200 sesiones y miles de nodos — pero tu gateway puede saturarse y n8n puede acumular ejecuciones si un workflow tarda más que el intervalo de polling.

Regla práctica: Para datos de producción (contadores, estados), cada 30-60 segundos es más que suficiente. Para alarmas críticas, usa suscripciones OPC-UA en el gateway en lugar de polling.

No gestionar reconexiones

Los PLCs se reinician. Las redes tienen cortes. El gateway debe reconectarse automáticamente cuando pierde la conexión con el PLC. La librería node-opcua gestiona reconexiones si configuras los parámetros de keep-alive, pero debes probarlo. Desconecta el cable de red del PLC y verifica que el gateway se recupera solo cuando vuelve la conexión.

Mezclar lectura y escritura sin control

Leer datos del PLC desde n8n es seguro. Escribir valores en el PLC desde n8n es peligroso si no hay validación. Un error en un workflow que escribe un setpoint de 500 °C en lugar de 50 °C puede provocar un accidente. Si necesitas escribir, añade límites de rango en el gateway y requiere confirmación manual para valores fuera de rango.

Olvidar los permisos del DB en TIA Portal

El error más frecuente de todos: configuras todo perfectamente, arrancas el gateway, y no ves ninguna variable. Vuelves a TIA Portal y descubres que no marcaste la casilla “Accesible desde OPC-UA” en el DB. Pasa más veces de las que nadie admite.

Escalar la solución: de una máquina a toda la planta

Una vez que tienes la primera máquina conectada y funcionando, escalar es cuestión de repetir el patrón. Cada PLC adicional se conecta al mismo gateway (o a uno nuevo si la carga lo justifica) y los workflows de n8n se parametrizan para manejar múltiples fuentes.

Consejos para el escalado:

• Un gateway puede servir a varios PLCs. Añade un endpoint que acepte la IP del PLC como parámetro y gestiona un pool de sesiones OPC-UA.
• Usa variables de entorno en n8n para no hardcodear IPs ni nodeIds en cada workflow.
• Centraliza la configuración de qué variables leer de cada máquina en un archivo JSON o en una tabla de base de datos. El workflow lee la configuración, itera sobre las máquinas y procesa los datos de forma dinámica.
• Monitoriza el gateway con un health check periódico desde n8n. Si el gateway no responde, envía alerta.

Alternativas al gateway Node.js

El microservicio Node.js es la opción que recomiendo por flexibilidad y coste (gratis), pero no es la única:

Prosys OPC-UA Forge / Gateway — Producto comercial de Prosys que traduce OPC-UA a REST, MQTT y otros protocolos. Interfaz gráfica, sin código, soporte profesional. Ideal si tu empresa prefiere soluciones con soporte y no quiere mantener código propio. Precio: desde 500 €/año.

Unified Automation UaGateway — Otra opción comercial con funcionalidades similares. Orientado a entornos con muchos servidores OPC-UA.

Kepware KEPServerEX — El veterano. Conecta con prácticamente cualquier PLC del mercado y expone los datos por REST, MQTT u OPC-UA. Es la navaja suiza, pero el precio refleja esa versatilidad.

Node-RED como bridge — Si ya usas Node-RED, el nodo node-red-contrib-opcua puede actuar de puente entre el PLC y n8n. Node-RED lee OPC-UA y publica en un endpoint HTTP o MQTT que n8n consume. Funciona, pero añade una herramienta más que mantener.

Para una primera implementación o un proyecto pequeño, el gateway Node.js propio es la mejor relación coste-funcionalidad. Cuando la planta tiene 20+ máquinas y el proyecto es crítico, un Kepware o Prosys te quita dolores de cabeza.

Lo que esta integración significa para tu fábrica

Conectar un PLC Siemens con n8n no es solo un proyecto técnico. Es un cambio de mentalidad. Pasas de tener máquinas que operan en su burbuja a tener máquinas que comunican, reportan y activan procesos automáticamente.

Los datos de producción llegan solos a la hoja de cálculo del director. Las alarmas críticas saltan en Telegram antes de que el operador llegue al teléfono. Los lotes se registran en el ERP sin que nadie escriba un número. El mantenimiento recibe avisos predictivos en lugar de llamadas de emergencia.

Y todo esto con herramientas open source (o casi) que un ingeniero de automatización puede montar, mantener y escalar sin depender de un departamento de IT ni de licencias de software de seis cifras.

El PLC Siemens ya hacía bien su trabajo. Ahora también habla con el resto del mundo.

---

¿Necesitas conectar tus PLCs Siemens con sistemas IT pero no sabes por dónde empezar? En automatizatodo.com llevamos años integrando mundos OT e IT en fábricas reales. Te ayudamos desde la configuración de OPC-UA en TIA Portal hasta los workflows de n8n en producción. Contacta con nosotros y montamos una prueba de concepto en tu planta.