275 lines
8.7 KiB
JavaScript
275 lines
8.7 KiB
JavaScript
const { outputUtils, configManager } = require("generalFunctions");
|
|
const Specific = require("./specificClass");
|
|
|
|
class nodeClass {
|
|
/**
|
|
* Create a MeasurementNode.
|
|
* @param {object} uiConfig - Node-RED node configuration.
|
|
* @param {object} RED - Node-RED runtime API.
|
|
* @param {object} nodeInstance - The Node-RED node instance.
|
|
* @param {string} nameOfNode - The name of the node, used for
|
|
*/
|
|
constructor(uiConfig, RED, nodeInstance, nameOfNode) {
|
|
// Preserve RED reference for HTTP endpoints if needed
|
|
this.node = nodeInstance; // This is the Node-RED node instance, we can use this to send messages and update status
|
|
this.RED = RED; // This is the Node-RED runtime API, we can use this to create endpoints if needed
|
|
this.name = nameOfNode; // This is the name of the node, it should match the file name and the node type in Node-RED
|
|
this.source = null; // Will hold the specific class instance
|
|
|
|
// Load default & UI config
|
|
this._loadConfig(uiConfig, this.node);
|
|
|
|
// Instantiate core Measurement class
|
|
this._setupSpecificClass();
|
|
|
|
// Wire up event and lifecycle handlers
|
|
this._bindEvents();
|
|
this._registerChild();
|
|
this._startTickLoop();
|
|
this._attachInputHandler();
|
|
this._attachCloseHandler();
|
|
}
|
|
|
|
/**
|
|
* Load and merge default config with user-defined settings.
|
|
* @param {object} uiConfig - Raw config from Node-RED UI.
|
|
*/
|
|
_loadConfig(uiConfig, node) {
|
|
const cfgMgr = new configManager();
|
|
this.defaultConfig = cfgMgr.getConfig(this.name);
|
|
|
|
// Merge UI config over defaults
|
|
this.config = {
|
|
general: {
|
|
name: uiConfig.name,
|
|
id: node.id, // node.id is for the child registration process
|
|
unit: uiConfig.unit, // add converter options later to convert to default units (need like a model that defines this which units we are going to use and then conver to those standards)
|
|
logging: {
|
|
enabled: uiConfig.enableLog,
|
|
logLevel: uiConfig.logLevel,
|
|
},
|
|
},
|
|
functionality: {
|
|
positionVsParent: uiConfig.positionVsParent || "atEquipment", // Default to 'atEquipment' if not set
|
|
},
|
|
};
|
|
// Utility for formatting outputs
|
|
this._output = new outputUtils();
|
|
}
|
|
|
|
_updateNodeStatus() {
|
|
const mg = this.source;
|
|
const mode = mg.mode;
|
|
const scaling = mg.scaling;
|
|
|
|
// Add safety checks for measurements
|
|
const totalFlow = mg.measurements
|
|
?.type("flow")
|
|
?.variant("predicted")
|
|
?.position("downstream")
|
|
?.getCurrentValue() || 0;
|
|
|
|
const totalPower = mg.measurements
|
|
?.type("power")
|
|
?.variant("predicted")
|
|
?.position("upstream")
|
|
?.getCurrentValue() || 0;
|
|
|
|
// Calculate total capacity based on available machines with safety checks
|
|
const availableMachines = Object.values(mg.machines || {}).filter((machine) => {
|
|
// Safety check: ensure machine and machine.state exist
|
|
if (!machine || !machine.state || typeof machine.state.getCurrentState !== 'function') {
|
|
console.warn(`Machine missing or invalid:`, machine?.config?.general?.id || 'unknown');
|
|
return false;
|
|
}
|
|
|
|
const state = machine.state.getCurrentState();
|
|
const mode = machine.currentMode;
|
|
return !(
|
|
state === "off" ||
|
|
state === "maintenance" ||
|
|
mode === "maintenance"
|
|
);
|
|
});
|
|
|
|
const totalCapacity = Math.round((mg.dynamicTotals?.flow?.max || 0) * 1) / 1;
|
|
|
|
// Determine overall status based on available machines
|
|
const status = availableMachines.length > 0
|
|
? `${availableMachines.length} machine(s) connected`
|
|
: "No machines";
|
|
|
|
let scalingSymbol = "";
|
|
switch ((scaling || "").toLowerCase()) {
|
|
case "absolute":
|
|
scalingSymbol = "Ⓐ";
|
|
break;
|
|
case "normalized":
|
|
scalingSymbol = "Ⓝ";
|
|
break;
|
|
default:
|
|
scalingSymbol = mode || "";
|
|
break;
|
|
}
|
|
|
|
const text = ` ${mode || 'Unknown'} | ${scalingSymbol}: 💨=${Math.round(totalFlow)}/${totalCapacity} | ⚡=${Math.round(totalPower)} | ${status}`;
|
|
|
|
return {
|
|
fill: availableMachines.length > 0 ? "green" : "red",
|
|
shape: "dot",
|
|
text,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Instantiate the core logic and store as source.
|
|
*/
|
|
_setupSpecificClass() {
|
|
this.source = new Specific(this.config);
|
|
this.node.source = this.source; // Store the source in the node instance for easy access
|
|
}
|
|
|
|
/**
|
|
* Bind events to Node-RED status updates. Using internal emitter. --> REMOVE LATER WE NEED ONLY COMPLETE CHILDS AND THEN CHECK FOR UPDATES
|
|
*/
|
|
_bindEvents() {
|
|
this.source.emitter.on("mAbs", (val) => {
|
|
this.node.status({
|
|
fill: "green",
|
|
shape: "dot",
|
|
text: `${val} ${this.config.general.unit}`,
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Register this node as a child upstream and downstream.
|
|
* Delayed to avoid Node-RED startup race conditions.
|
|
*/
|
|
_registerChild() {
|
|
setTimeout(() => {
|
|
this.node.send([
|
|
null,
|
|
null,
|
|
{
|
|
topic: "registerChild",
|
|
payload: this.node.id,
|
|
positionVsParent:
|
|
this.config?.functionality?.positionVsParent || "atEquipment",
|
|
},
|
|
]);
|
|
}, 100);
|
|
}
|
|
|
|
/**
|
|
* Start the periodic tick loop to drive the Measurement class.
|
|
*/
|
|
_startTickLoop() {
|
|
setTimeout(() => {
|
|
this._tickInterval = setInterval(() => this._tick(), 1000);
|
|
// Update node status on nodered screen every second ( this is not the best way to do this, but it works for now)
|
|
this._statusInterval = setInterval(() => {
|
|
const status = this._updateNodeStatus();
|
|
this.node.status(status);
|
|
}, 1000);
|
|
}, 1000);
|
|
}
|
|
|
|
/**
|
|
* Execute a single tick: update measurement, format and send outputs.
|
|
*/
|
|
_tick() {
|
|
const raw = this.source.getOutput();
|
|
const processMsg = this._output.formatMsg(raw, this.config, "process");
|
|
const influxMsg = this._output.formatMsg(raw, this.config, "influxdb");
|
|
|
|
// Send only updated outputs on ports 0 & 1
|
|
this.node.send([processMsg, influxMsg]);
|
|
}
|
|
|
|
/**
|
|
* Attach the node's input handler, routing control messages to the class.
|
|
*/
|
|
_attachInputHandler() {
|
|
this.node.on(
|
|
"input",
|
|
async (msg, send, done) => {
|
|
const mg = this.source;
|
|
const RED = this.RED;
|
|
switch (msg.topic) {
|
|
case "registerChild":
|
|
console.log(`Registering child in mgc: ${msg.payload}`);
|
|
const childId = msg.payload;
|
|
const childObj = RED.nodes.getNode(childId);
|
|
|
|
// Debug: Check what we're getting
|
|
console.log(`Child object:`, childObj ? 'found' : 'NOT FOUND');
|
|
console.log(`Child source:`, childObj?.source ? 'exists' : 'MISSING');
|
|
if (childObj?.source) {
|
|
console.log(`Child source type:`, childObj.source.constructor.name);
|
|
console.log(`Child has state:`, !!childObj.source.state);
|
|
}
|
|
|
|
mg.childRegistrationUtils.registerChild(
|
|
childObj.source,
|
|
msg.positionVsParent
|
|
);
|
|
|
|
// Debug: Check machines after registration
|
|
console.log(`Total machines after registration:`, Object.keys(mg.machines || {}).length);
|
|
break;
|
|
|
|
case "setMode":
|
|
const mode = msg.payload;
|
|
const source = "parent";
|
|
mg.setMode(source, mode);
|
|
break;
|
|
|
|
case "setScaling":
|
|
const scaling = msg.payload;
|
|
mg.setScaling(scaling);
|
|
|
|
break;
|
|
|
|
case "Qd":
|
|
const Qd = parseFloat(msg.payload);
|
|
const sourceQd = "parent";
|
|
|
|
if (isNaN(Qd)) {
|
|
return mg.logger.error(`Invalid demand value: ${Qd}`);
|
|
}
|
|
|
|
try {
|
|
await mg.handleInput(sourceQd, Qd);
|
|
msg.topic = mg.config.general.name;
|
|
msg.payload = "done";
|
|
send(msg);
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Handle unknown topics if needed
|
|
mg.logger.warn(`Unknown topic: ${msg.topic}`);
|
|
break;
|
|
}
|
|
done();
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Clean up timers and intervals when Node-RED stops the node.
|
|
*/
|
|
_attachCloseHandler() {
|
|
this.node.on("close", (done) => {
|
|
clearInterval(this._tickInterval);
|
|
clearInterval(this._statusInterval);
|
|
done();
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = nodeClass; // Export the class for Node-RED to use
|