ThingsBoard (Edge Setup)

// Rich telemetry generator for ThingBoard dashboards
// Put this in a Function node and trigger it every 1s-5s with an Inject node.

let s = context.get('s') || {
    t: 0,
    baseTemp: 24,
    baseHum: 48,
    motorOn: true,
    speedRpm: 900,
    energyKWh: 0,
    runtimeSec: 0,
    cycleCount: 0,
    lastCycleT: 0,
    fault: false,
    faultCode: 0
};

s.t += 1;

// Helpers
function clamp(v, min, max) { return Math.max(min, Math.min(max, v)); }
function rand(min, max) { return min + Math.random() * (max - min); }
function chance(p) { return Math.random() < p; }

// ---- Motor state machine (feels realistic)
if (chance(0.02)) s.motorOn = !s.motorOn;              // occasional start/stop
if (chance(0.01) && !s.fault) {                        // rare fault event
    s.fault = true;
    s.faultCode = [101, 202, 303, 404][Math.floor(Math.random() * 4)];
}
if (s.fault && chance(0.15)) {                         // fault clears after some time
    s.fault = false;
    s.faultCode = 0;
}

// Speed ramping
let targetRpm = s.motorOn && !s.fault ? rand(800, 1450) : 0;
s.speedRpm = s.speedRpm + (targetRpm - s.speedRpm) * 0.15;
s.speedRpm = clamp(s.speedRpm, 0, 1600);

// ---- Environmental signals (slow drift + small noise)
let dayWave = Math.sin(s.t / 120) * 1.5;               // slow wave
s.baseTemp += rand(-0.02, 0.02);
s.baseHum += rand(-0.05, 0.05);

let temperature = clamp(s.baseTemp + dayWave + rand(-0.2, 0.2), 18, 35);
let humidity    = clamp(s.baseHum - dayWave + rand(-0.5, 0.5), 30, 70);

// ---- Vibration rises with RPM + faults
let vibBase = (s.speedRpm / 1600) * 4.0;               // 0..4 mm/s
let vibrationRms = vibBase + rand(0.1, 0.5);
if (s.fault) vibrationRms += rand(2, 5);               // big increase when faulty
vibrationRms = clamp(vibrationRms, 0, 12);

// ---- Current / Power / Energy
let currentA = s.motorOn && !s.fault ? clamp((s.speedRpm / 1600) * 7 + rand(0, 1), 0, 10) : rand(0, 0.3);
if (s.fault) currentA += rand(2, 4);

let voltageV = 230 + rand(-3, 3);
let powerW = clamp(voltageV * currentA * 0.85, 0, 4000);   // rough PF/efficiency

// energy integration: Wh per second -> kWh
s.energyKWh += (powerW / 1000) / 3600;

// ---- Production-ish signals
if (s.motorOn && !s.fault) s.runtimeSec += 1;

// create a "cycle" every ~15-35 seconds when running
if (s.motorOn && !s.fault && (s.t - s.lastCycleT) > rand(15, 35)) {
    s.cycleCount += 1;
    s.lastCycleT = s.t;
}
let cycleTimeSec = s.motorOn && !s.fault ? clamp((s.t - s.lastCycleT), 0, 60) : null;

// ---- Quality / OEE-ish
let rejectRate = s.fault ? rand(3, 12) : rand(0.3, 2.0);   // %
let goodParts = Math.round(s.cycleCount * (1 - rejectRate / 100));
let availability = clamp((s.runtimeSec / s.t) * 100, 0, 100);

// ---- Alarm levels (nice for color-changing widgets)
let alarmLevel = 0;
if (temperature > 30 || vibrationRms > 7) alarmLevel = 1;
if (s.fault || vibrationRms > 9) alarmLevel = 2;

// Build payload
msg.payload = {
    // Environment
    temperature: Number(temperature.toFixed(2)),          // °C
    humidity: Number(humidity.toFixed(2)),                // %

    // Machine
    motorOn: s.motorOn && !s.fault,                       // boolean
    speedRpm: Math.round(s.speedRpm),
    vibrationRms: Number(vibrationRms.toFixed(2)),        // mm/s
    currentA: Number(currentA.toFixed(2)),                // A
    voltageV: Number(voltageV.toFixed(1)),                // V
    powerW: Math.round(powerW),                           // W
    energyKWh: Number(s.energyKWh.toFixed(3)),            // kWh

    // Production / KPIs
    cycleCount: s.cycleCount,
    cycleTimeSec: cycleTimeSec === null ? null : Number(cycleTimeSec.toFixed(1)),
    goodParts: goodParts,
    rejectRate: Number(rejectRate.toFixed(2)),            // %
    availability: Number(availability.toFixed(1)),        // %

    // Faults / Alarms
    fault: s.fault,
    faultCode: s.faultCode,
    alarmLevel: alarmLevel                               // 0 normal, 1 warn, 2 critical
};

context.set('s', s);
return msg;