Implementation Guide: Trigger preventive maintenance schedules based on equipment run hours

# Example VLAN configuration on a managed switch (Cisco/HP syntax varies)
# On the client's core switch:
configure terminal
vlan 100
name OT-Sensors
exit
interface range GigabitEthernet 0/20-22
switchport mode access
switchport access vlan 100
exit
# On the firewall (example pfSense/OPNsense rules):
# Allow VLAN 100 -> Internet on ports 443 (HTTPS) and 8883 (MQTTS)
# Allow VLAN 100 -> Edge Server IP on ports 1883 (MQTT), 8086 (InfluxDB), 1880 (Node-RED)
# Deny all other traffic from VLAN 100

# SSH into the Moxa gateway (default IP varies, check Moxa documentation)
ssh moxa@192.168.100.10
# Set static IP (edit Moxa network config or use Moxa's web-based tool)
sudo nano /etc/network/interfaces
# Configure: address 10.100.0.11, netmask 255.255.255.0, gateway 10.100.0.1

# Install Mosquitto MQTT Broker
sudo apt-get update
sudo apt-get install -y mosquitto mosquitto-clients

# Configure Mosquitto with authentication
sudo nano /etc/mosquitto/conf.d/default.conf
# Add the following:
# listener 1883
# allow_anonymous false
# password_file /etc/mosquitto/passwd

# Create MQTT user
sudo mosquitto_passwd -c /etc/mosquitto/passwd iot_gateway
# Enter password when prompted

sudo systemctl enable mosquitto
sudo systemctl start mosquitto

# Install Node-RED (if not pre-installed on Moxa Industrial Linux)
sudo apt-get install -y nodejs npm
sudo npm install -g --unsafe-perm node-red

# Install Node-RED as a systemd service
sudo nano /etc/systemd/system/nodered.service
# [Unit]
# Description=Node-RED
# After=network.target
# [Service]
# ExecStart=/usr/bin/node-red --max-old-space-size=256
# Restart=on-failure
# User=moxa
# [Install]
# WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable nodered
sudo systemctl start nodered

# Verify services are running
sudo systemctl status mosquitto
sudo systemctl status nodered

# Test MQTT locally
mosquitto_pub -h localhost -u iot_gateway -P <password> -t test/hello -m 'Gateway online'
mosquitto_sub -h localhost -u iot_gateway -P <password> -t test/hello

# Install Ubuntu Server 22.04 LTS (standard installation)
# After installation, set static IP:
sudo nano /etc/netplan/00-installer-config.yaml
# network:
#   ethernets:
#     eno1:
#       dhcp4: no
#       addresses: [10.100.0.5/24]
#       gateway4: 10.100.0.1
#       nameservers:
#         addresses: [8.8.8.8, 8.8.4.4]
#   version: 2
sudo netplan apply

# Install Docker
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker $USER

# Create project directory
mkdir -p ~/pm-automation && cd ~/pm-automation

# Create docker-compose.yml (see custom_ai_components for full file)
nano docker-compose.yml

# Create Mosquitto config
mkdir -p mosquitto/config mosquitto/data mosquitto/log
nano mosquitto/config/mosquitto.conf
# persistence true
# persistence_location /mosquitto/data/
# log_dest file /mosquitto/log/mosquitto.log
# listener 1883
# allow_anonymous false
# password_file /mosquitto/config/passwd

# Create MQTT password file
docker run --rm -v $(pwd)/mosquitto/config:/mosquitto/config eclipse-mosquitto mosquitto_passwd -c /mosquitto/config/passwd pm_system

# Create InfluxDB data directory
mkdir -p influxdb/data

# Create Grafana data directory
mkdir -p grafana/data && sudo chown -R 472:472 grafana/data

# Start all services
docker compose up -d

# Verify all containers are running
docker compose ps

asset_name, asset_code, site, area, category, make, model, serial_number
CNC-Mill-01, CNC01, Main Plant, Machine Shop, CNC Machine, Haas, VF-2SS, SN12345
CNC-Mill-02, CNC02, Main Plant, Machine Shop, CNC Machine, Haas, VF-2SS, SN12346
Compressor-01, COMP01, Main Plant, Utilities, Air Compressor, Ingersoll Rand, R-Series R11i, SN98765

POST https://api.fiixsoftware.com/api/v2/meters
Authorization: Bearer <API_TOKEN>
Content-Type: application/json

{
  "name": "Run Hours - CNC01",
  "unit": "Hours",
  "assetId": 12345,
  "meterType": "CUMULATIVE"
}

# Install required Node-RED palette nodes
cd ~/.node-red
npm install node-red-contrib-influxdb
npm install node-red-contrib-ncd-wireless
npm install node-red-node-smooth

# Restart Node-RED to load new nodes
sudo systemctl restart nodered

# Generate Fiix API credentials via the Fiix web UI:
# Settings → Integrations → API Keys → + New API Key
# Save the Client ID and Client Secret securely

# Test API authentication (get OAuth2 bearer token):
curl -X POST https://api.fiixsoftware.com/api/v2/auth/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'grant_type=client_credentials&client_id=<CLIENT_ID>&client_secret=<CLIENT_SECRET>'

# Response will include: { "access_token": "eyJ...", "expires_in": 3600 }

# Test submitting a meter reading:
curl -X POST https://api.fiixsoftware.com/api/v2/meter-readings \
  -H 'Authorization: Bearer <ACCESS_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{
    "meterId": 12345,
    "reading": 100.5,
    "readingDate": "2025-01-15T10:30:00Z"
  }'

# Verify in Fiix UI: Navigate to the asset → Meters tab → confirm reading appears

# Test PM trigger: Submit a reading that exceeds the PM threshold
# Then check: Work Orders → Open → verify a new PM work order was auto-created

# Store credentials as environment variables on the edge server:
echo 'export FIIX_CLIENT_ID=<your_client_id>' >> ~/.bashrc
echo 'export FIIX_CLIENT_SECRET=<your_client_secret>' >> ~/.bashrc
source ~/.bashrc

# Access Grafana UI at http://10.100.0.5:3000
# Default credentials: admin / admin (change on first login)

# Add InfluxDB data source:
# Configuration → Data Sources → Add data source → InfluxDB
# URL: http://influxdb:8086 (Docker internal hostname) or http://10.100.0.5:8086
# Database: pm_automation
# User: <influxdb_user>
# Password: <influxdb_password>
# HTTP Method: GET
# Save & Test

# Example InfluxDB query for Grafana panel (run hours gauge per machine):
# SELECT last("run_hours_total") FROM "equipment_runtime" WHERE "asset_id" = 'CNC01' AND $timeFilter GROUP BY time(1h) fill(previous)

# Example query for equipment utilization % (hours running / hours in period):
# SELECT (last("run_hours_total") - first("run_hours_total")) / (($__interval_ms / 3600000) * 1.0) * 100 FROM "equipment_runtime" WHERE "asset_id" = 'CNC01' AND $timeFilter GROUP BY time(1d)

# Inject test MQTT message simulating high current (machine running):
mosquitto_pub -h 10.100.0.5 -u pm_system -P <password> \
  -t 'plant/zone1/CNC01/current' \
  -m '{"sensor_id":"NCD-001","current_rms":15.2,"battery_v":3.4,"timestamp":"2025-01-15T10:00:00Z"}'

# Verify in Node-RED: check debug tab for processed message
# Verify in InfluxDB:
curl -G 'http://10.100.0.5:8086/query' \
  --data-urlencode 'db=pm_automation' \
  --data-urlencode 'q=SELECT last(*) FROM equipment_runtime WHERE asset_id=\'CNC01\''

# Inject test meter reading to Fiix to force PM trigger:
# (Adjust the reading value to exceed the configured PM threshold)
curl -X POST https://api.fiixsoftware.com/api/v2/meter-readings \
  -H 'Authorization: Bearer <TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"meterId": <CNC01_METER_ID>, "reading": 501.0, "readingDate": "2025-01-15T12:00:00Z"}'

# Check Fiix for auto-generated work order
# Check technician's phone for push notification

# To add a new asset to the Node-RED configuration, update the asset_config context:
# In Node-RED, edit the 'Asset Configuration' change node and add the new asset:
{
  "asset_id": "PRESS-03",
  "sensor_topic": "plant/zone2/PRESS03/current",
  "current_threshold": 5.0,
  "fiix_meter_id": 67890,
  "pm_thresholds": [
    { "hours": 250, "pm_type": "Lubrication" },
    { "hours": 1000, "pm_type": "Major Service" }
  ]
}

# Deploy the updated flow in Node-RED

# Save to ~/pm-automation/docker-compose.yml

# docker-compose.yml
# Save to ~/pm-automation/docker-compose.yml

version: '3.8'

services:
  mosquitto:
    image: eclipse-mosquitto:2
    container_name: pm-mosquitto
    restart: unless-stopped
    ports:
      - '1883:1883'
      - '9001:9001'
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
      - ./mosquitto/log:/mosquitto/log
    networks:
      - pm-network

  nodered:
    image: nodered/node-red:3-18
    container_name: pm-nodered
    restart: unless-stopped
    ports:
      - '1880:1880'
    volumes:
      - ./nodered/data:/data
    environment:
      - TZ=America/Chicago
      - FIIX_CLIENT_ID=${FIIX_CLIENT_ID}
      - FIIX_CLIENT_SECRET=${FIIX_CLIENT_SECRET}
      - FIIX_API_URL=https://api.fiixsoftware.com/api/v2
    depends_on:
      - mosquitto
      - influxdb
    networks:
      - pm-network

  influxdb:
    image: influxdb:1.8
    container_name: pm-influxdb
    restart: unless-stopped
    ports:
      - '8086:8086'
    volumes:
      - ./influxdb/data:/var/lib/influxdb
    environment:
      - INFLUXDB_DB=pm_automation
      - INFLUXDB_ADMIN_USER=admin
      - INFLUXDB_ADMIN_PASSWORD=${INFLUXDB_ADMIN_PASSWORD}
      - INFLUXDB_USER=pm_writer
      - INFLUXDB_USER_PASSWORD=${INFLUXDB_USER_PASSWORD}
      - INFLUXDB_READ_USER=pm_reader
      - INFLUXDB_READ_USER_PASSWORD=${INFLUXDB_READ_PASSWORD}
    networks:
      - pm-network

  grafana:
    image: grafana/grafana-oss:10.2.0
    container_name: pm-grafana
    restart: unless-stopped
    ports:
      - '3000:3000'
    volumes:
      - ./grafana/data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    depends_on:
      - influxdb
    networks:
      - pm-network

networks:
  pm-network:
    driver: bridge

# Create a .env file alongside docker-compose.yml:
# FIIX_CLIENT_ID=your_client_id
# FIIX_CLIENT_SECRET=your_client_secret
# INFLUXDB_ADMIN_PASSWORD=securepassword1
# INFLUXDB_USER_PASSWORD=securepassword2
# INFLUXDB_READ_PASSWORD=securepassword3
# GRAFANA_ADMIN_PASSWORD=securepassword4

# Import via Menu → Import → Clipboard. Implements the complete run-hour
# accumulation and PM trigger pipeline.

// Node-RED Flow JSON — Import via Menu → Import → Clipboard
// This flow implements the complete run-hour accumulation and PM trigger pipeline.
// 
// FLOW OVERVIEW:
// 1. MQTT In nodes subscribe to sensor topics per zone
// 2. JSON parse node extracts current_rms value
// 3. Asset Lookup function maps sensor_id to asset configuration
// 4. Running State Detector compares current to threshold
// 5. Hour Accumulator increments run hours when machine is running
// 6. InfluxDB Write stores data points
// 7. Fiix API Updater pushes meter readings at scheduled intervals
// 8. Sensor Health Monitor detects stale/missing sensors
//
// CONFIGURATION:
// Edit the 'Asset Configuration' function node to define your assets.
// Each asset needs: asset_id, sensor_id, current_threshold_amps, fiix_meter_id

[
  {
    "id": "mqtt-broker-config",
    "type": "mqtt-broker",
    "name": "Local MQTT Broker",
    "broker": "mosquitto",
    "port": "1883",
    "clientid": "nodered-pm-engine",
    "autoConnect": true,
    "usetls": false,
    "credentials": {
      "user": "pm_system",
      "password": ""
    }
  },
  {
    "id": "mqtt-in-sensors",
    "type": "mqtt in",
    "name": "All Sensor Data",
    "topic": "plant/+/+/current",
    "qos": "1",
    "datatype": "json",
    "broker": "mqtt-broker-config",
    "wires": [["parse-sensor-data"]]
  },
  {
    "id": "parse-sensor-data",
    "type": "function",
    "name": "Parse & Enrich Sensor Data",
    "func": "// Extract zone and machine from MQTT topic\n// Topic format: plant/{zone}/{machine_id}/current\nconst topicParts = msg.topic.split('/');\/\nmsg.zone = topicParts[1];\nmsg.machine_id = topicParts[2];\nmsg.current_rms = msg.payload.current_rms || 0;\nmsg.battery_v = msg.payload.battery_v || 0;\nmsg.sensor_id = msg.payload.sensor_id || msg.machine_id;\nmsg.timestamp = new Date().toISOString();\nreturn msg;",
    "wires": [["asset-lookup"]]
  },
  {
    "id": "asset-lookup",
    "type": "function",
    "name": "Asset Configuration Lookup",
    "func": "// ============================================\n// ASSET CONFIGURATION - EDIT THIS FOR EACH CLIENT\n// ============================================\nconst ASSETS = {\n  'CNC01': {\n    asset_id: 'CNC01',\n    asset_name: 'CNC Mill #1 (Haas VF-2SS)',\n    sensor_id: 'NCD-001',\n    current_threshold_amps: 3.0,\n    fiix_meter_id: 12345,\n    fiix_asset_id: 67890,\n    pm_schedules: [\n      { type: 'Lubrication', interval_hours: 250 },\n      { type: 'Filter Change', interval_hours: 500 },\n      { type: 'Major Service', interval_hours: 2000 }\n    ]\n  },\n  'CNC02': {\n    asset_id: 'CNC02',\n    asset_name: 'CNC Mill #2 (Haas VF-2SS)',\n    sensor_id: 'NCD-002',\n    current_threshold_amps: 3.0,\n    fiix_meter_id: 12346,\n    fiix_asset_id: 67891,\n    pm_schedules: [\n      { type: 'Lubrication', interval_hours: 250 },\n      { type: 'Filter Change', interval_hours: 500 },\n      { type: 'Major Service', interval_hours: 2000 }\n    ]\n  },\n  'COMP01': {\n    asset_id: 'COMP01',\n    asset_name: 'Air Compressor #1 (IR R-Series)',\n    sensor_id: 'NCD-010',\n    current_threshold_amps: 5.0,\n    fiix_meter_id: 12350,\n    fiix_asset_id: 67895,\n    pm_schedules: [\n      { type: 'Oil Change', interval_hours: 500 },\n      { type: 'Air Filter', interval_hours: 250 },\n      { type: 'Separator Element', interval_hours: 4000 }\n    ]\n  }\n  // ADD MORE ASSETS HERE following the same pattern\n};\n\nconst asset = ASSETS[msg.machine_id];\nif (!asset) {\n  node.warn('Unknown machine_id: ' + msg.machine_id);\n  return null; // Drop unknown sensors\n}\nmsg.asset = asset;\nreturn msg;",
    "wires": [["running-state-detector", "sensor-health-check", "battery-check"]]
  },
  {
    "id": "running-state-detector",
    "type": "function",
    "name": "Running State Detector",
    "func": "// Determine if machine is running based on current threshold\n// Uses hysteresis to prevent chattering at threshold boundary\nconst HYSTERESIS = 0.5; // amps\nconst asset = msg.asset;\nconst current = msg.current_rms;\n\n// Get previous state from persistent context\nconst stateKey = 'state_' + asset.asset_id;\nconst prevState = flow.get(stateKey) || { running: false, last_change: Date.now() };\n\nlet isRunning;\nif (prevState.running) {\n  // Machine was running — only stop if current drops below (threshold - hysteresis)\n  isRunning = current >= (asset.current_threshold_amps - HYSTERESIS);\n} else {\n  // Machine was stopped — only start if current exceeds (threshold + hysteresis)\n  isRunning = current >= (asset.current_threshold_amps + HYSTERESIS);\n}\n\n// Detect state change\nconst stateChanged = (isRunning !== prevState.running);\nif (stateChanged) {\n  prevState.last_change = Date.now();\n  node.log(asset.asset_id + ' state changed to: ' + (isRunning ? 'RUNNING' : 'STOPPED'));\n}\nprevState.running = isRunning;\nflow.set(stateKey, prevState);\n\nmsg.is_running = isRunning;\nmsg.state_changed = stateChanged;\nreturn msg;",
    "wires": [["hour-accumulator"]]
  },
  {
    "id": "hour-accumulator",
    "type": "function",
    "name": "Run Hour Accumulator",
    "func": "// Accumulate run hours using persistent file-backed context\n// Uses time delta between readings to calculate fractional hours\nconst asset = msg.asset;\nconst hoursKey = 'hours_' + asset.asset_id;\nconst lastSeenKey = 'lastseen_' + asset.asset_id;\n\n// Get persisted values\nlet totalHours = global.get(hoursKey, 'file') || 0;\nconst lastSeen = global.get(lastSeenKey, 'file') || Date.now();\nconst now = Date.now();\n\n// Calculate time delta in hours\nconst deltaMs = now - lastSeen;\nconst deltaHours = deltaMs / (1000 * 60 * 60);\n\n// Safety: ignore deltas > 1 hour (indicates restart or gap)\nif (deltaHours > 1.0) {\n  node.warn(asset.asset_id + ': Large time gap detected (' + deltaHours.toFixed(2) + ' hrs). Skipping accumulation for this interval.');\n} else if (msg.is_running && deltaHours > 0) {\n  totalHours += deltaHours;\n}\n\n// Persist updated values\nglobal.set(hoursKey, totalHours, 'file');\nglobal.set(lastSeenKey, now, 'file');\n\nmsg.run_hours_total = Math.round(totalHours * 100) / 100;\nmsg.delta_hours = Math.round(deltaHours * 1000) / 1000;\n\nreturn msg;",
    "wires": [["influxdb-write", "fiix-update-throttle"]]
  },
  {
    "id": "influxdb-write",
    "type": "function",
    "name": "Format for InfluxDB",
    "func": "msg.payload = [\n  {\n    measurement: 'equipment_runtime',\n    tags: {\n      asset_id: msg.asset.asset_id,\n      asset_name: msg.asset.asset_name,\n      zone: msg.zone\n    },\n    fields: {\n      current_rms: msg.current_rms,\n      is_running: msg.is_running ? 1 : 0,\n      run_hours_total: msg.run_hours_total,\n      battery_v: msg.battery_v\n    },\n    timestamp: new Date()\n  }\n];\nreturn msg;",
    "wires": [["influxdb-out"]]
  },
  {
    "id": "influxdb-out",
    "type": "influxdb out",
    "name": "Write to InfluxDB",
    "influxdb": "influxdb-config",
    "measurement": "",
    "wires": []
  },
  {
    "id": "influxdb-config",
    "type": "influxdb",
    "name": "PM Automation DB",
    "hostname": "influxdb",
    "port": "8086",
    "database": "pm_automation",
    "credentials": {
      "username": "pm_writer",
      "password": ""
    }
  },
  {
    "id": "fiix-update-throttle",
    "type": "delay",
    "name": "Throttle: 1 msg per asset per hour",
    "pauseType": "rate",
    "timeout": "1",
    "timeoutUnits": "hours",
    "rate": "1",
    "nbRateUnits": "1",
    "rateUnits": "hour",
    "randomFirst": "1",
    "randomLast": "5",
    "randomUnits": "seconds",
    "drop": true,
    "wires": [["fiix-auth"]]
  },
  {
    "id": "fiix-auth",
    "type": "function",
    "name": "Fiix OAuth2 Token Manager",
    "func": "// Manage Fiix API OAuth2 token with caching\nconst tokenData = flow.get('fiix_token') || {};\nconst now = Date.now();\n\n// Check if token is still valid (with 5-minute buffer)\nif (tokenData.access_token && tokenData.expires_at && tokenData.expires_at > (now + 300000)) {\n  msg.fiix_token = tokenData.access_token;\n  return [msg, null]; // First output: token valid, proceed\n}\n\n// Token expired or missing — request new token\nconst authMsg = {\n  method: 'POST',\n  url: (env.get('FIIX_API_URL') || 'https://api.fiixsoftware.com/api/v2') + '/auth/token',\n  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n  payload: 'grant_type=client_credentials' +\n           '&client_id=' + encodeURIComponent(env.get('FIIX_CLIENT_ID')) +\n           '&client_secret=' + encodeURIComponent(env.get('FIIX_CLIENT_SECRET')),\n  _originalMsg: msg\n};\nreturn [null, authMsg]; // Second output: need new token",
    "outputs": 2,
    "wires": [["fiix-meter-update"], ["fiix-auth-request"]]
  },
  {
    "id": "fiix-auth-request",
    "type": "http request",
    "name": "Fiix Auth Request",
    "method": "POST",
    "ret": "obj",
    "wires": [["fiix-auth-response"]]
  },
  {
    "id": "fiix-auth-response",
    "type": "function",
    "name": "Cache Auth Token",
    "func": "if (msg.statusCode === 200 && msg.payload.access_token) {\n  const tokenData = {\n    access_token: msg.payload.access_token,\n    expires_at: Date.now() + (msg.payload.expires_in * 1000)\n  };\n  flow.set('fiix_token', tokenData);\n  \n  // Restore original message and add token\n  const origMsg = msg._originalMsg;\n  origMsg.fiix_token = tokenData.access_token;\n  return origMsg;\n} else {\n  node.error('Fiix auth failed: ' + JSON.stringify(msg.payload));\n  return null;\n}",
    "wires": [["fiix-meter-update"]]
  },
  {
    "id": "fiix-meter-update",
    "type": "function",
    "name": "Format Fiix Meter Reading",
    "func": "msg.method = 'POST';\nmsg.url = (env.get('FIIX_API_URL') || 'https://api.fiixsoftware.com/api/v2') + '/meter-readings';\nmsg.headers = {\n  'Authorization': 'Bearer ' + msg.fiix_token,\n  'Content-Type': 'application/json'\n};\nmsg.payload = {\n  meterId: msg.asset.fiix_meter_id,\n  reading: msg.run_hours_total,\n  readingDate: new Date().toISOString()\n};\n\nnode.log('Updating Fiix meter ' + msg.asset.fiix_meter_id + ' for ' + msg.asset.asset_id + ': ' + msg.run_hours_total + ' hours');\nreturn msg;",
    "wires": [["fiix-api-call"]]
  },
  {
    "id": "fiix-api-call",
    "type": "http request",
    "name": "Fiix API Call",
    "method": "use",
    "ret": "obj",
    "wires": [["fiix-response-handler"]]
  },
  {
    "id": "fiix-response-handler",
    "type": "function",
    "name": "Handle Fiix API Response",
    "func": "if (msg.statusCode >= 200 && msg.statusCode < 300) {\n  node.log('Fiix meter update successful: ' + JSON.stringify(msg.payload));\n} else if (msg.statusCode === 401) {\n  // Token expired mid-flight, clear cached token\n  flow.set('fiix_token', null);\n  node.warn('Fiix auth token expired, will refresh on next cycle');\n} else {\n  node.error('Fiix API error (' + msg.statusCode + '): ' + JSON.stringify(msg.payload));\n}\nreturn null; // Terminal node",
    "wires": []
  },
  {
    "id": "sensor-health-check",
    "type": "function",
    "name": "Sensor Health Monitor",
    "func": "// Track last-seen timestamp for each sensor\nconst healthKey = 'health_' + msg.asset.asset_id;\nflow.set(healthKey, {\n  last_seen: Date.now(),\n  battery_v: msg.battery_v,\n  current_rms: msg.current_rms,\n  sensor_id: msg.sensor_id\n});\nreturn null; // Just stores, no output",
    "wires": []
  },
  {
    "id": "battery-check",
    "type": "function",
    "name": "Battery Low Alert",
    "func": "// Alert if battery voltage drops below 2.5V (NCD sensors nominal 3.0-3.6V)\nconst LOW_BATTERY_THRESHOLD = 2.5;\nif (msg.battery_v > 0 && msg.battery_v < LOW_BATTERY_THRESHOLD) {\n  msg.payload = {\n    alert: 'LOW_BATTERY',\n    asset_id: msg.asset.asset_id,\n    asset_name: msg.asset.asset_name,\n    sensor_id: msg.sensor_id,\n    battery_v: msg.battery_v,\n    message: 'Sensor battery low on ' + msg.asset.asset_name + ' (' + msg.battery_v + 'V). Replace batteries soon.'\n  };\n  return msg;\n}\nreturn null;",
    "wires": [["alert-email"]]
  },
  {
    "id": "alert-email",
    "type": "e-mail",
    "name": "Send Battery Alert Email",
    "server": "smtp.client.com",
    "port": "587",
    "to": "msp-alerts@mspcompany.com",
    "subject": "[PM System] Low Battery Alert - {{payload.asset_name}}",
    "wires": []
  }
]

# import alongside the main flow

// Additional Node-RED flow — import alongside the main flow
// This flow checks sensor health every 15 minutes

[
  {
    "id": "health-cron",
    "type": "inject",
    "name": "Every 15 Minutes",
    "repeat": "900",
    "crontab": "",
    "once": true,
    "onceDelay": "60",
    "payload": "",
    "payloadType": "date",
    "wires": [["check-all-sensors"]]
  },
  {
    "id": "check-all-sensors",
    "type": "function",
    "name": "Check All Sensor Health",
    "func": "// List of all expected asset IDs (must match Asset Configuration)\nconst EXPECTED_ASSETS = ['CNC01', 'CNC02', 'COMP01']; // EDIT FOR EACH CLIENT\nconst STALE_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes\nconst now = Date.now();\nconst alerts = [];\n\nfor (const assetId of EXPECTED_ASSETS) {\n  const healthKey = 'health_' + assetId;\n  const health = flow.get(healthKey);\n  \n  if (!health) {\n    alerts.push({\n      asset_id: assetId,\n      issue: 'NEVER_SEEN',\n      message: assetId + ': Sensor has never reported data. Check installation.'\n    });\n  } else {\n    const age = now - health.last_seen;\n    if (age > STALE_THRESHOLD_MS) {\n      const minutesAgo = Math.round(age / 60000);\n      alerts.push({\n        asset_id: assetId,\n        issue: 'STALE',\n        message: assetId + ': Last sensor reading was ' + minutesAgo + ' minutes ago. Possible sensor failure or wireless connectivity issue.',\n        last_battery_v: health.battery_v\n      });\n    }\n  }\n}\n\nif (alerts.length > 0) {\n  msg.payload = {\n    alert_type: 'SENSOR_HEALTH',\n    alert_count: alerts.length,\n    alerts: alerts,\n    summary: alerts.length + ' sensor(s) reporting issues: ' + alerts.map(a => a.asset_id).join(', ')\n  };\n  msg.topic = 'Sensor Health Alert';\n  return msg;\n}\nreturn null; // No alerts, no output",
    "wires": [["health-alert-email"]]
  },
  {
    "id": "health-alert-email",
    "type": "e-mail",
    "name": "Send Health Alert to MSP",
    "server": "smtp.mspcompany.com",
    "port": "587",
    "to": "noc@mspcompany.com, maintenance.manager@client.com",
    "subject": "[PM System] Sensor Health Alert - {{payload.summary}}",
    "wires": []
  }
]

// NOTE: Update the EXPECTED_ASSETS array to match all monitored assets.
// This flow is essential for MSP monitoring — it catches the failure mode
// where a sensor silently dies, which would otherwise result in missed PMs
// because run hours stop accumulating.

// Node-RED flow for handling PM work order completions
// Two approaches: Webhook (preferred) or Polling

// APPROACH 1: Fiix Webhook (if available on your Fiix plan)
[
  {
    "id": "fiix-webhook-in",
    "type": "http in",
    "name": "Fiix Work Order Webhook",
    "url": "/api/fiix/wo-complete",
    "method": "post",
    "wires": [["validate-webhook"]]
  },
  {
    "id": "validate-webhook",
    "type": "function",
    "name": "Validate & Process WO Completion",
    "func": "// Validate the webhook payload\nconst wo = msg.payload;\n\n// Check if this is a PM work order completion\nif (wo.status !== 'Completed' || wo.workOrderType !== 'PreventiveMaintenance') {\n  // Not relevant, acknowledge but don't process\n  msg.statusCode = 200;\n  msg.payload = { status: 'ignored', reason: 'Not a completed PM' };\n  return [null, msg]; // Second output: HTTP response\n}\n\n// Map Fiix asset ID to our asset_id\nconst FIIX_ASSET_MAP = {\n  67890: 'CNC01',\n  67891: 'CNC02',\n  67895: 'COMP01'\n  // ADD ALL ASSET MAPPINGS HERE\n};\n\nconst assetId = FIIX_ASSET_MAP[wo.assetId];\nif (!assetId) {\n  node.warn('Unknown Fiix asset ID in WO completion: ' + wo.assetId);\n  msg.statusCode = 200;\n  msg.payload = { status: 'ignored', reason: 'Unknown asset' };\n  return [null, msg];\n}\n\nmsg.asset_id = assetId;\nmsg.fiix_wo = wo;\n\n// Determine which PM type was completed and calculate reset\n// IMPORTANT: Fiix meter-based PMs typically auto-set the next trigger\n// (e.g., current reading + interval). The meter itself is CUMULATIVE\n// and should NOT be reset to zero. Instead, Fiix tracks the 'next due at'\n// reading internally.\n//\n// However, we may want to log the completion for our own tracking:\nmsg.payload = {\n  event: 'PM_COMPLETED',\n  asset_id: assetId,\n  work_order: wo.code,\n  completed_at: wo.completedDate,\n  current_hours: global.get('hours_' + assetId, 'file') || 0\n};\n\nnode.log('PM completed for ' + assetId + ' at ' + msg.payload.current_hours + ' hours');\n\n// HTTP response\nconst responseMsg = { statusCode: 200, payload: { status: 'processed' } };\nreturn [msg, responseMsg];",
    "outputs": 2,
    "wires": [["log-pm-completion"], ["webhook-response"]]
  },
  {
    "id": "webhook-response",
    "type": "http response",
    "name": "Webhook ACK",
    "statusCode": "200",
    "wires": []
  },
  {
    "id": "log-pm-completion",
    "type": "function",
    "name": "Log PM Completion to InfluxDB",
    "func": "msg.payload = [{\n  measurement: 'pm_completions',\n  tags: {\n    asset_id: msg.asset_id\n  },\n  fields: {\n    work_order: msg.fiix_wo.code,\n    hours_at_completion: msg.payload.current_hours\n  },\n  timestamp: new Date()\n}];\nreturn msg;",
    "wires": [["influxdb-out"]]
  }
]

// APPROACH 2: Polling (if webhooks not available)
// Add an inject node on a 30-minute schedule that calls:
// GET /api/v2/work-orders?status=Completed&completedDateAfter=<last_check>
// Process results through similar logic as above.
//
// CRITICAL NOTE ON METER BEHAVIOR:
// Fiix uses CUMULATIVE meters for run hours. The meter value always goes UP.
// When you configure a meter-based PM in Fiix with interval=500 hours,
// Fiix will trigger the first PM at 500 hours, then automatically set the
// next trigger at 1000 hours, then 1500, etc.
// You do NOT need to reset the meter to zero after each PM.
// The Node-RED run-hour accumulator should therefore also be cumulative
// (which it is, as implemented in the main flow).
// This simplifies the system significantly — no reset logic needed.

// NCD Wireless Sensor → MQTT Bridge
// This runs as a separate Node-RED flow on each gateway that has an NCD USB receiver

// Step 1: Install the NCD Node-RED package
// In Node-RED: Menu → Manage Palette → Install → search 'node-red-contrib-ncd-wireless'
// Or via command line: cd ~/.node-red && npm install node-red-contrib-ncd-wireless

// Step 2: Import this flow on each gateway:
[
  {
    "id": "ncd-serial-config",
    "type": "ncd-gateway-config",
    "name": "NCD USB Receiver",
    "comm_type": "serial",
    "serial_port": "/dev/ttyUSB0",
    "serial_baud": "115200"
  },
  {
    "id": "ncd-gateway-node",
    "type": "ncd-gateway-node",
    "name": "NCD Gateway",
    "connection": "ncd-serial-config",
    "wires": [["ncd-sensor-decode"]]
  },
  {
    "id": "ncd-sensor-decode",
    "type": "function",
    "name": "Decode NCD Sensor & Publish to MQTT",
    "func": "// NCD sensor data arrives as a JSON object with sensor_id and readings\n// Map NCD sensor IDs to machine IDs and zone\nconst SENSOR_MAP = {\n  'NCD-001': { zone: 'zone1', machine_id: 'CNC01' },\n  'NCD-002': { zone: 'zone1', machine_id: 'CNC02' },\n  'NCD-003': { zone: 'zone1', machine_id: 'CNC03' },\n  'NCD-004': { zone: 'zone1', machine_id: 'CNC04' },\n  'NCD-005': { zone: 'zone1', machine_id: 'CNC05' },\n  'NCD-010': { zone: 'zone2', machine_id: 'COMP01' },\n  'NCD-011': { zone: 'zone2', machine_id: 'COMP02' },\n  'NCD-012': { zone: 'zone2', machine_id: 'PRESS01' },\n  'NCD-013': { zone: 'zone2', machine_id: 'PRESS02' },\n  'NCD-014': { zone: 'zone2', machine_id: 'PRESS03' }\n  // ADD ALL SENSORS FOR THIS GATEWAY'S ZONE\n};\n\nconst sensorId = msg.payload.addr || msg.payload.sensor_id || 'unknown';\nconst mapping = SENSOR_MAP[sensorId];\n\nif (!mapping) {\n  node.warn('Unknown NCD sensor: ' + sensorId);\n  return null;\n}\n\n// Extract current reading (NCD AC current sensor type)\n// NCD current sensors report RMS current in amps\nconst currentRms = msg.payload.current || msg.payload.sensor_data?.current_rms || 0;\nconst batteryV = msg.payload.battery || msg.payload.sensor_data?.battery || 0;\n\nmsg.topic = 'plant/' + mapping.zone + '/' + mapping.machine_id + '/current';\nmsg.payload = {\n  sensor_id: sensorId,\n  current_rms: currentRms,\n  battery_v: batteryV,\n  timestamp: new Date().toISOString()\n};\n\nreturn msg;",
    "wires": [["mqtt-out-bridge"]]
  },
  {
    "id": "mqtt-out-bridge",
    "type": "mqtt out",
    "name": "Publish to MQTT",
    "topic": "",
    "qos": "1",
    "retain": false,
    "broker": "mqtt-broker-config",
    "wires": []
  }
]

// NOTE: The NCD node-red-contrib-ncd-wireless package handles the low-level
// serial communication with the NCD USB receiver. The sensor_id format and
// payload structure may vary slightly depending on the NCD firmware version.
// Test with one sensor first and inspect the raw payload in Node-RED debug
// to confirm the field names match. Adjust the decode function accordingly.
//
// If using the centralized edge server architecture (recommended), configure
// each gateway's Mosquitto as an MQTT bridge to forward all messages to the
// central broker:
//
// On gateway's mosquitto.conf, add:
// connection central-broker
// address 10.100.0.5:1883
// topic plant/# out 1
// remote_username pm_system
// remote_password <password>
// bridge_protocol_version mqttv311

# confirms sensor data is being written over the last hour

curl -G 'http://10.100.0.5:8086/query' --data-urlencode 'db=pm_automation' --data-urlencode 'q=SELECT count(*) FROM equipment_runtime WHERE time > now() - 1h'