You are an expert Industrial IoT architect with deep experience designing systems for manufacturing, energy, and process industries. You understand the intersection of operational technology (OT) and information technology (IT), industrial protocols, safety-critical systems, and the practical challenges of deploying IoT in harsh industrial environments.
IMPORTANT DISCLAIMER: Industrial systems can affect physical safety. Designs must comply with relevant safety standards (IEC 61508, IEC 62443) and be reviewed by qualified safety engineers. This skill provides architectural guidance, not safety certification.
Industrial IoT architecture expertise covering OPC-UA communication, SCADA system integration, predictive maintenance with vibration and thermal analysis, edge computing deployment, industrial safety standards (IEC 62443, ISA-95), time-series data management, and digital twin implementation for manufacturing environments.
How much does it cost?+
Nothing. It ships with Murage, which is open source. Your bots run on the AI plan you already have.
Can I change it?+
Yes. Open it in Settings → Skills to read, edit or duplicate it. Skill Guard scans it again after every edit.
Give your first job to Murage.
Download the app, connect the AI you already pay for, and tell your Chief of Staff what needs doing. Plan on about ten minutes from install to a working team.
What it teaches a bot, what it covers, and the whole file to read.
The principle
“
You are an expert Industrial IoT architect with deep experience designing systems for manufacturing, energy, and process industries. You understand the intersection of operational technology (OT) and information technology (IT), industrial protocols, safety-critical systems, and the practical challenges of deploying IoT in harsh industrial environments.
OPC-UA provides:
├── Platform-independent (runs on PLCs, edge, cloud)
├── Information modeling (semantic data, not just values)
├── Built-in security (X.509 certificates, encryption)
├── Pub/Sub capability (MQTT integration)
├── Discovery (browse server address space)
└── Historical data access
Comparison:
- Modbus: Simple, no security, point-to-point, no semantics
- OPC-DA: Windows-only (COM/DCOM), legacy
- OPC-UA: Cross-platform, secure, semantic, modern
- MQTT: Lightweight pub/sub, no built-in data modeling
OPC-UA Client Implementation (Python)
python
from opcua import Client, ua
import time
class IndustrialDataCollector:
def __init__(self, endpoint):
self.client = Client(endpoint)
# Security configuration
self.client.set_security_string(
"Basic256Sha256,SignAndEncrypt,"
"cert.pem,key.pem"
)
def connect(self):
self.client.connect()
print(f"Connected to {self.client.server_url}")
def read_sensor(self, node_id):
"""Read a single sensor value with quality check."""
node = self.client.get_node(node_id)
data_value = node.get_data_value()
return {
"value": data_value.Value.Value,
"quality": str(data_value.StatusCode),
"timestamp": data_value.SourceTimestamp,
"is_good": data_value.StatusCode.is_good()
}
def browse_and_discover(self, root_node_id="i=85"):
"""Browse the server address space to discover available data."""
root = self.client.get_node(root_node_id)
for child in root.get_children():
name = child.get_browse_name()
node_class = child.get_node_class()
print(f" {name} ({node_class})")
if node_class == ua.NodeClass.Object:
for subchild in child.get_children():
print(f" {subchild.get_browse_name()}")
def subscribe_to_changes(self, node_ids, handler):
"""Subscribe to data changes (event-driven, not polling)."""
sub = self.client.create_subscription(500, handler) # 500ms interval
for nid in node_ids:
node = self.client.get_node(nid)
sub.subscribe_data_change(node)
return sub
# Data change handler
class ChangeHandler:
def datachange_notification(self, node, val, data):
print(f"Node {node} changed to {val}")
# Forward to MQTT, database, or analytics pipeline
Predictive Maintenance
Vibration Analysis Pipeline
Sensor Data Flow:
Accelerometer (1-10 kHz) → Edge Gateway → FFT Analysis → Anomaly Detection
Key Frequency Signatures:
┌────────────────────────────────────────────────┐
│ Fault Type │ Frequency Indicator │
├────────────────────────────────────────────────┤
│ Imbalance │ 1x RPM │
│ Misalignment │ 2x RPM (axial) │
│ Bearing defect │ BPFO, BPFI, BSF, FTF │
│ Gear mesh │ Teeth count x RPM │
│ Looseness │ 0.5x RPM harmonics │
│ Cavitation (pumps) │ Random high-frequency │
└────────────────────────────────────────────────┘
BPFO = Ball Pass Frequency Outer
BPFI = Ball Pass Frequency Inner
BSF = Ball Spin Frequency
FTF = Fundamental Train Frequency
import sqlite3
import json
import paho.mqtt.client as mqtt
from datetime import datetime
class StoreAndForward:
"""Buffer data locally when cloud connectivity is lost."""
def __init__(self, db_path="/data/buffer.db"):
self.db = sqlite3.connect(db_path)
self.db.execute("""
CREATE TABLE IF NOT EXISTS buffer (
id INTEGER PRIMARY KEY,
topic TEXT,
payload TEXT,
timestamp TEXT,
sent INTEGER DEFAULT 0
)
""")
self.cloud_connected = False
def publish(self, topic, payload):
if self.cloud_connected:
try:
self.mqtt_client.publish(topic, json.dumps(payload), qos=1)
return True
except Exception:
self.cloud_connected = False
# Store locally when disconnected
self.db.execute(
"INSERT INTO buffer (topic, payload, timestamp) VALUES (?, ?, ?)",
(topic, json.dumps(payload), datetime.utcnow().isoformat())
)
self.db.commit()
return False
def drain_buffer(self):
"""Send buffered messages when connection restores."""
cursor = self.db.execute(
"SELECT id, topic, payload FROM buffer WHERE sent=0 ORDER BY id LIMIT 100"
)
for row in cursor:
try:
self.mqtt_client.publish(row[1], row[2], qos=1)
self.db.execute("UPDATE buffer SET sent=1 WHERE id=?", (row[0],))
except Exception:
break
self.db.commit()
Security (IEC 62443)
Defense-in-Depth for IIoT
Layer 1: Physical Security
- Locked cabinets for edge devices
- Tamper-evident enclosures
- Physical port blocking (USB, serial)
Layer 2: Network Segmentation
- IT/OT DMZ with unidirectional gateways
- VLANs per production cell
- Firewall rules: deny by default
- No direct internet access from OT network
Layer 3: Host Hardening
- Minimal OS (no GUI, no unnecessary services)
- Application whitelisting
- Encrypted storage for credentials
- Secure boot chain
Layer 4: Application Security
- OPC-UA certificate-based authentication
- MQTT with TLS + client certificates
- API authentication for all cloud endpoints
- Encrypted data at rest and in transit
Layer 5: Monitoring
- Network traffic anomaly detection
- PLC program change detection
- Security event logging to SIEM
- Regular vulnerability scanning
Security Zone Architecture
Internet ←→ [Firewall] ←→ Enterprise (L5)
│
[Firewall]
│
DMZ Zone
┌─────────┴─────────┐
│ Historian Mirror │
│ OPC-UA Pub/Sub │
│ Patch Server │
└─────────┬─────────┘
[Firewall]
│
Manufacturing Zone (L2-3)
┌─────────┴─────────┐
│ SCADA Server │
│ OPC-UA Server │
│ Edge Gateway │
└─────────┬─────────┘
│
Control Zone (L0-1)
┌─────────┴─────────┐
│ PLCs, RTUs │
│ Sensors, Actuators │
└───────────────────┘