Comprehensive Scripting Engine & IO Mapping Guide

The Anatomy of an IO Mapping Element

System Scripts Infrastructure Scope

System scripts are structural automation entities designed to perform global account tasks, background security health checks, system performance optimizations, or cluster-wide notifications. They sit above individual device dashboards and interface with internal system logs, telemetry error diagnostics, or administrative cron triggers.

Standard User Scripts Application Scope

Standard scripts are application-specific logic containers tightly coupled to user dashboards and specific field installations. They focus on processing mapped IO variable tables, validating physical parameters, executing device cross-talk, and updating custom visualization widgets.

Example 1: Signal Smoothing Filter (Outlier Rejection & Mean)

Intent: Evaluates noisy analog sensor data, drops extreme maximum and minimum spikes, and returns the stable arithmetic average over a sliding historical window.

// Set the maximum element window size for tracking history
const HISTORICAL_BUFFER_LIMIT = 5;

// Extract raw measurement input from mapped IO configuration
const incomingRawRecord = inputs.waterLevelSensor.value;

// Crash protection guard clause: Verify field data availability
if (incomingRawRecord === null || incomingRawRecord === undefined || incomingRawRecord === "") {
    console.log("Telemetry packet unallocated or offline. Aborting logic loop.");
    return;
}

// Cast string variables to float numbers
const cleanNumericValue = Number(incomingRawRecord);
if (isNaN(cleanNumericValue)) {
    console.log("Error: Passed value parameter is not an acceptable number structure.");
    return;
}

// Rehydrate historical array structure from output persistent variable memory string
let historicalDataWindow = [];
try {
    historicalDataWindow = JSON.parse(outputs.memoryBufferCache || "[]");
} catch (parsingException) {
    historicalDataWindow = [];
}

// Place the newest sensor reading at the front of the array index (Position 0)
historicalDataWindow.unshift(cleanNumericValue);

// Truncate old data records that exceed boundary capacity thresholds
if (historicalDataWindow.length > HISTORICAL_BUFFER_LIMIT) {
    historicalDataWindow = historicalDataWindow.slice(0, HISTORICAL_BUFFER_LIMIT);
}

// Serialize active array cache state back to storage field
outputs.memoryBufferCache = JSON.stringify(historicalDataWindow);

// Ensure enough array coordinates exist to reject outlier noise spikes
if (historicalDataWindow.length < 3) {
    console.log("Populating buffer elements. Ongoing length: " + historicalDataWindow.length);
    return;
}

// Clone the array and apply sorting to isolate extreme values
let sortedArrayInstance = [...historicalDataWindow].sort((alpha, beta) => alpha - beta);
sortedArrayInstance.pop();   // Purge absolute peak noise spike
sortedArrayInstance.shift(); // Purge absolute low noise drop

// Sum remaining stable samples
const combinedSum = sortedArrayInstance.reduce((accumulator, currentElement) => accumulator + currentElement, 0);
const calculatedArithmeticMean = combinedSum / sortedArrayInstance.length;

// Output the smoothed value rounded to two decimal points
outputs.smoothedOutputRegister = Math.round(calculatedArithmeticMean * 100) / 100;
console.log("Signal filtering cycle finished smoothly.");

Example 2: Operational Tolerance Bounds Gate

Intent: Verifies incoming data sits inside safe mechanical boundaries before committing changes to tracking registers.

// Define critical hardware operation thresholds
const SAFETY_FLOOR_LIMIT = 5.0;
const SAFETY_CEILING_LIMIT = 95.0;

const rawTelemetryData = inputs.pressureInputSensor.value;

// Validate input existence
if (rawTelemetryData === null || rawTelemetryData === undefined || rawTelemetryData === "") {
    console.log("Data stream unreachable. Execution suspended.");
    return;
}

const parsedPressureMetric = Number(rawTelemetryData);
if (isNaN(parsedPressureMetric)) {
    return;
}

// Evaluate if parameter falls within valid operational tolerances
if (parsedPressureMetric >= SAFETY_FLOOR_LIMIT && parsedPressureMetric <= SAFETY_CEILING_LIMIT) {
    outputs.validatedPressureOutput = parsedPressureMetric;
    console.log("Data falls within safe tolerances. Logging record.");
} else {
    console.log("Alert: Hardware boundary exception encountered. Value dropped!");
    return;
}

Example 3: Dynamic Multi-Channel Resolution Scaling

Intent: Processes a high-resolution signal and generates separate outputs for integer values and two-decimal floats.

const rawHighResInput = inputs.preciseAdcSensor.value;

// Halt execution if data field initializes empty
if (rawHighResInput === null || rawHighResInput === undefined || rawHighResInput === "") {
    console.log("Awaiting field parameter assignment updates.");
    return;
}

const nativeFloatValue = Number(rawHighResInput);
if (isNaN(nativeFloatValue)) {
    console.log("Invalid format parameter detected.");
    return;
}

// Map high-resolution values to discrete user interface requirements
outputs.integerDisplayChannel = Math.round(nativeFloatValue);
outputs.precisionFloatDisplayChannel = Math.round(nativeFloatValue * 100) / 100;

console.log("Multi-channel scaling finished successfully.");

Example 4: Persistent Integration Totalizer (Accumulator)

Intent: Continuously adds the current sensor input metric to a running historical summation. Ideal for flow meters, pulse counters, or power metrics.

const rawFlowIncrement = inputs.flowSensorPulse.value;

// Validate input metrics
if (rawFlowIncrement === null || rawFlowIncrement === undefined || rawFlowIncrement === "") {
    console.log("No pulse or flow increments found.");
    return;
}

const incrementalVolume = Number(rawFlowIncrement);
if (isNaN(incrementalVolume)) {
    return;
}

// Retrieve past long-term sum total from tracking record column
let historicalAccumulatedSum = outputs.cumulativeTotalStorage;

// Protect against null states during initial system configuration run
if (historicalAccumulatedSum === undefined || historicalAccumulatedSum === null || isNaN(historicalAccumulatedSum)) {
    historicalAccumulatedSum = 0.0;
}

// Append incremental volume to long-term database counter
outputs.cumulativeTotalStorage = historicalAccumulatedSum + incrementalVolume;
console.log("Cumulative summation total updated successfully.");

Example 5: Global Historical Low Peak Capture

Intent: Monitors operational temperatures and records the absolute historical low value encountered across all device runs.

const rawTemperatureReading = inputs.ambientTempSensor.value;

// Validate sensor metrics
if (rawTemperatureReading === null || rawTemperatureReading === undefined || rawTemperatureReading === "") {
    console.log("Temperature line scanning unallocated.");
    return;
}

const currentTemperatureValue = Number(rawTemperatureReading);
if (isNaN(currentTemperatureValue)) {
    return;
}

// Fetch previous historical minimum value baseline
const recordedHistoricalMinimum = outputs.historicalLowRecord;

// Update record if a new low temperature is detected or if it's the first run
if (recordedHistoricalMinimum === undefined || recordedHistoricalMinimum === null || currentTemperatureValue < recordedHistoricalMinimum) {
    outputs.historicalLowRecord = currentTemperatureValue;
    console.log("New historical low parameter captured: " + currentTemperatureValue);
} else {
    outputs.historicalLowRecord = recordedHistoricalMinimum;
}

Example 6: MQTT Payload String JSON Demultiplexer

const serializedMqttPayload = inputs.gatewayJsonString.value;

// Validate that string attributes exist
if (typeof serializedMqttPayload !== 'string' || serializedMqttPayload.trim() === "") {
    console.log("Payload data stream does not match expected JSON string rules.");
    return;
}

try {
    // Decode the raw string back into a structural JavaScript Object
    const nestedDataObject = JSON.parse(serializedMqttPayload);
    
    // Route sub-properties to individual output channels if present
    if (nestedDataObject.humidity !== undefined) {
        outputs.isolatedHumidityChannel = nestedDataObject.humidity;
    }
    if (nestedDataObject.temperature !== undefined) {
        outputs.isolatedTemperatureChannel = nestedDataObject.temperature;
    }
    
    console.log("JSON parsing and data routing tasks finished.");
} catch (jsonParsingException) {
    console.log("Fatal Error: Failed to evaluate JSON syntax rules.");
    return;
}

Example 7: Multi-Input Logic Safety Interlock (AND / OR)

Intent: Evaluates status signals from separate physical environments before issuing hardware relay permissions.

const emergencyStopSwitch = inputs.estopStatus.value;
const tankLevelPressure = inputs.pressureHighFlag.value;

// Verify that all dependency attributes are online
if (emergencyStopSwitch === null || emergencyStopSwitch === "" || tankLevelPressure === null || tankLevelPressure === "") {
    console.log("Critical safety dependencies are offline. Suspending logic checks.");
    return;
}

const estopActiveState = Number(emergencyStopSwitch);
const pressureOverloadState = Number(tankLevelPressure);

// Execute interlocking evaluations using logical operators
if (estopActiveState === 0 && pressureOverloadState === 0) {
    outputs.masterSafetyRelayCmd = 1; // Safe condition: Energize line relay
    console.log("Safety parameters cleared. Output relay active.");
} else {
    outputs.masterSafetyRelayCmd = 0; // Hazard condition: De-energize output instantly
    console.log("Hazard alert: Interlock triggered. Disabling line relay.");
}

Example 8: Engineered Linear Calibration Translation

Intent: Translates raw ADC values via the standard linear calibration formula ($y = ax + b$).

const rawAdcVoltageReading = inputs.rawAdcRegister.value;

// Verify interface availability
if (rawAdcVoltageReading === null || rawAdcVoltageReading === undefined || rawAdcVoltageReading === "") {
    console.log("ADC interface frame missing.");
    return;
}

const primitiveAdcValue = Number(rawAdcVoltageReading);
if (isNaN(primitiveAdcValue)) {
    return; 
}

// Convert raw integer profiles to real engineering units (e.g., Temperature Celsius)
// Coefficient scale factor: 1.82, Zero-offset intercept value: 12.40
const engineeringScaledMetric = (primitiveAdcValue * 1.82) + 12.40;

outputs.calibratedCelsiusOutput = Math.round(engineeringScaledMetric * 100) / 100;
console.log("Linear transformation mapping complete.");

Example 9: Inter-Device Differential Deviation Evaluator

Intent: Monitors variance between two matching physical environment sensors and flags maintenance alerts if they drift apart.

const internalZoneSensor = inputs.chamberSensorA.value;
const externalZoneSensor = inputs.chamberSensorB.value;

// Ensure both telemetry lines are reachable
if (internalZoneSensor === null || internalZoneSensor === "" || externalZoneSensor === null || externalZoneSensor === "") {
    console.log("Awaiting telemetry sync updates from redundant lines.");
    return;
}

const readingValueA = Number(internalZoneSensor);
const readingValueB = Number(externalZoneSensor);

if (isNaN(readingValueA) || isNaN(readingValueB)) {
    return;
}

// Calculate absolute difference between the redundant nodes
const variationMagnitude = Math.abs(readingValueA - readingValueB);

// Trigger maintenance alarms if drift variance exceeds 4.5 operational points
if (variationMagnitude > 4.5) {
    outputs.sensorDriftAlarmTrigger = 1; // Set alarm state high
    console.log("Maintenance alert: Redundant sensors out of sync!");
} else {
    outputs.sensorDriftAlarmTrigger = 0; // Clear alarm status
}

outputs.monitoredVarianceTrack = variationMagnitude;

Example 10: Digital Setpoint Actuator Relay with Hysteresis Guard

Intent: Triggers a digital command bit using a deadband buffer window to prevent rapid on/off cycling (chattering) at boundary thresholds.

// Define thermostat target limits with deadband buffer rules
const COLD_SETPOINT_LIMIT = 22.0;
const HYSTERESIS_BUFFER_RANGE = 1.5;

const rawChamberTemp = inputs.liveRoomTemperature.value;

if (rawChamberTemp === null || rawChamberTemp === undefined || rawChamberTemp === "") {
    console.log("Thermostat tracking loop inactive: Data stream unmapped.");
    return;
}

const physicalTemperature = Number(rawChamberTemp);
if (isNaN(physicalTemperature)) {
    return;
}

// Fetch current compressor state to evaluate step directions
let ongoingCompressorState = outputs.compressorPowerRelay;
if (ongoingCompressorState === undefined || ongoingCompressorState === null) {
    ongoingCompressorState = 0;
}

// Execute thermostat logic tracking with built-in hysteresis deadband values
if (physicalTemperature > (COLD_SETPOINT_LIMIT + HYSTERESIS_BUFFER_RANGE)) {
    outputs.compressorPowerRelay = 1; // Engage cooling actuator
    console.log("Threshold exceeded: Activating compressor cooling loop.");
} else if (physicalTemperature < (COLD_SETPOINT_LIMIT - HYSTERESIS_BUFFER_RANGE)) {
    outputs.compressorPowerRelay = 0; // Disengage cooling actuator
    console.log("Target limit met: Deactivating compressor loop.");
} else {
    // Maintain current state within deadband range to avoid short-cycling hardware
    outputs.compressorPowerRelay = ongoingCompressorState;
}