RnD/measurement
2
0
Fork 2
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

standaardisation of EVOLV eco

Browse Source
This commit is contained in:
znetsixe
2025-06-23 13:23:51 +02:00
parent 6f63415698
commit d05d521408
4 changed files with 394 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
measurement.html
View File

@@ -1,5 +1,6 @@
<script src="/measurement/menu.js"></script>
<script src="/measurement/menu.js"></script> <!-- Load the menu script for dynamic dropdowns -->
<script src="/measurement/configData.js"></script> <!-- Load the config script for node information -->
<script>
RED.nodes.registerType("measurement", {

189
measurement.js
View File

@@ -1,170 +1,47 @@
console.log('Loading measurement.js module...');
// load helper modules from the generalFunctions folder
const { outputUtils, MenuManager } = require('generalFunctions');
/**
* Thin wrapper that registers a node with Node-RED and exposes HTTP endpoints. and loads EVOLV in a standard way
*/
//internal node-red node dependencies this is the class that will handle the measurement
const Measurement = require("./dependencies/measurement/measurement");
console.log('All dependencies loaded successfully');
const nodeClass = require('./src/nodeClass.js');
const { MenuManager, configManager } = require('generalFunctions');
const nameOfNode = 'measurement';
module.exports = function(RED) {
function measurement(config) {
//create node
// Register the node type
RED.nodes.registerType(nameOfNode, function(config) {
// Initialize the Node-RED node first
RED.nodes.createNode(this, config);
//call this => node so whenver you want to call a node function type node and the function behind it
var node = this;
// Then create your custom class and attach it
this.nodeClass = new nodeClass(config, RED, this);
});
// Setup admin UIs
const menuMgr = new MenuManager();
const cfgMgr = new configManager();
console.log(`Loading endpoint for ${nameOfNode} menu...`);
// Register the menu for the measurement node
RED.httpAdmin.get('/measurement/menu.js', (req, res) => {
try {
//load user defined config in the node-red UI
const mConfig={
general: {
name: config.name,
id: node.id,
unit: config.unit,
logging:{
logLevel: config.logLevel,
enabled: config.enableLog,
},
},
asset: {
tagCode: config.assetTagCode,
supplier: config.supplier,
subType: config.subType,
model: config.model,
},
scaling:{
enabled: config.scaling,
inputMin: config.i_min,
inputMax: config.i_max,
absMin: config.o_min,
absMax: config.o_max,
offset: config.i_offset
},
smoothing: {
smoothWindow: config.count,
smoothMethod: config.smooth_method,
},
simulation: {
enabled: config.simulator,
},
const script = menuMgr.createEndpoint(nameOfNode, ['asset']);
res.type('application/javascript').send(script);
} catch (err) {
res.status(500).send(`// Error generating menu: ${err.message}`);
}
//make new measurement on creation to work with.
const m = new Measurement(mConfig);
// put m on node memory as source
node.source = m;
//load output utils
const output = new outputUtils();
function updateNodeStatus(val) {
//display status
node.status({ fill: "green", shape: "dot", text: val + " " + mConfig.general.unit });
}
//Update status only on event change
m.emitter.on('mAbs', (val) => {
updateNodeStatus(val);
});
//never ending functions
function tick(){
//kick class ticks for time move
m.tick();
//get output
const classOutput = m.getOutput();
const dbOutput = output.formatMsg(classOutput, m.config, "influxdb");
const pOutput = output.formatMsg(classOutput, m.config, "process");
//only send output on values that changed
let msgs = [];
msgs[0] = pOutput;
msgs[1] = dbOutput;
node.send(msgs);
}
// register child on first output this timeout is needed because of node - red stuff
setTimeout(
() => {
/*---execute code on first start----*/
let msgs = [];
msgs[2] = { topic : "registerChild" , payload: node.id, positionVsParent: "upstream" };
msgs[3] = { topic : "registerChild" , payload: node.id, positionVsParent: "downstream" };
//send msg
this.send(msgs);
},
100
);
//declare refresh interval internal node
setTimeout(
() => {
/*---execute code on first start----*/
this.intervalId = setInterval(function(){ tick() },1000)
},
1000
);
//-------------------------------------------------------------------->>what to do on input
node.on("input", function (msg,send,done) {
if(msg.topic == "simulator" ){
m.toggleSimulation();
}
if(msg.topic == "outlierDetection" ){
m.toggleOutlierDetection();
}
if(msg.topic == "calibrate" ){
m.calibrate();
}
if(msg.topic == "measurement" && typeof msg.payload == "number"){
//feed input into the measurement node and calculate output
m.inputValue = parseFloat(msg.payload);
}
done();
});
// tidy up any async code here - shutdown connections and so on.
node.on('close', function(done) {
if (node.intervalId) clearTimeout(node.intervalId);
if (node.tickInterval) clearInterval(node.tickInterval);
if (done) done();
});
}catch(e){
console.log(e);
}
}
RED.nodes.registerType("measurement", measurement);
const menuManager = new MenuManager();
RED.httpAdmin.get("/measurement/menu.js", (req, res) => {
console.log(`Loading endpoint for ${nameOfNode} config...`);
// Endpoint to get the configuration data for the measurement node
RED.httpAdmin.get(`/measurement/configData.js`, (req, res) => {
try {
const script = menuManager.createEndpoint('measurement', ['asset']);
res.set('Content-Type', 'application/javascript').send(script);
} catch (error) {
console.error("Error creating measurement menu script:", error);
res.status(500).send(`// Failed to generate menu data: ${error.message}`);
const script = cfgMgr.createEndpoint(nameOfNode);
// Send the configuration data as JSON response
res.type('application/javascript').send(script);
} catch (err) {
res.status(500).send(`// Error generating configData: ${err.message}`);
}
});
console.log('Measurement node and its menu data endpoint are registered.');
console.log(`Measurement node '${nameOfNode}' registered.`);
};

188
measurementOLD.js Normal file
View File

@@ -0,0 +1,188 @@
console.log('Loading measurement.js module...');
// load helper modules from the generalFunctions folder
const { outputUtils, MenuManager, configManager } = require('generalFunctions');
//internal node-red node dependencies this is the class that will handle the measurement
const Measurement = require("./dependencies/measurement/measurement");
console.log('All dependencies loaded successfully');
const nameOfNode = "measurement";
module.exports = function (RED) {
//load the config manager to get the default configs
this.configManager = new configManager();
this.defaultConfig = this.configManager.getConfig('measurement');
function measurement(config) {
//create node
RED.nodes.createNode(this, config);
//call this => node so whenver you want to call a node function type node and the function behind it
var node = this;
try{
//load user defined config in the node-red UI
const mConfig={
general: {
name: config.name,
id: node.id,
unit: config.unit,
logging:{
logLevel: config.logLevel,
enabled: config.enableLog,
},
},
asset: {
tagCode: config.assetTagCode,
supplier: config.supplier,
subType: config.subType,
model: config.model,
},
scaling:{
enabled: config.scaling,
inputMin: config.i_min,
inputMax: config.i_max,
absMin: config.o_min,
absMax: config.o_max,
offset: config.i_offset
},
smoothing: {
smoothWindow: config.count,
smoothMethod: config.smooth_method,
},
simulation: {
enabled: config.simulator,
},
}
//make new measurement on creation to work with.
const m = new Measurement(mConfig);
// put m on node memory as source
node.source = m;
//load output utils
const output = new outputUtils();
function updateNodeStatus(val) {
//display status
node.status({ fill: "green", shape: "dot", text: val + " " + mConfig.general.unit });
}
//Update status only on event change
m.emitter.on('mAbs', (val) => {
updateNodeStatus(val);
});
//never ending functions
function tick(){
//kick class ticks for time move
m.tick();
//get output
const classOutput = m.getOutput();
const dbOutput = output.formatMsg(classOutput, m.config, "influxdb");
const pOutput = output.formatMsg(classOutput, m.config, "process");
//only send output on values that changed
let msgs = [];
msgs[0] = pOutput;
msgs[1] = dbOutput;
node.send(msgs);
}
// register child on first output this timeout is needed because of node - red stuff
setTimeout(
() => {
/*---execute code on first start----*/
let msgs = [];
msgs[2] = { topic : "registerChild" , payload: node.id, positionVsParent: "upstream" };
msgs[3] = { topic : "registerChild" , payload: node.id, positionVsParent: "downstream" };
//send msg
this.send(msgs);
},
100
);
//declare refresh interval internal node
setTimeout(
() => {
/*---execute code on first start----*/
this.intervalId = setInterval(function(){ tick() },1000)
},
1000
);
//-------------------------------------------------------------------->>what to do on input
node.on("input", function (msg,send,done) {
if(msg.topic == "simulator" ){
m.toggleSimulation();
}
if(msg.topic == "outlierDetection" ){
m.toggleOutlierDetection();
}
if(msg.topic == "calibrate" ){
m.calibrate();
}
if(msg.topic == "measurement" && typeof msg.payload == "number"){
//feed input into the measurement node and calculate output
m.inputValue = parseFloat(msg.payload);
}
done();
});
// tidy up any async code here - shutdown connections and so on.
node.on('close', function(done) {
if (node.intervalId) clearTimeout(node.intervalId);
if (node.tickInterval) clearInterval(node.tickInterval);
if (done) done();
});
}catch(e){
console.log(e);
}
}
RED.nodes.registerType("measurement", measurement);
const menuManager = new MenuManager();
// Register the measurement menu handler
RED.httpAdmin.get("/measurement/menu.js", (req, res) => {
try {
const script = menuManager.createEndpoint('measurement', ['asset']);
res.set('Content-Type', 'application/javascript').send(script);
} catch (error) {
console.error("Error creating measurement menu script:", error);
res.status(500).send(`// Failed to generate menu data: ${error.message}`);
}
});
//register the measurement specific configs so the browser can access them
RED.httpAdmin.get("/measurement/configData", (req, res) => {
// load the config data from the JSON file and send it
try {
const configData = require('./dependencies/measurement/measurementConfig.json');
res.json(configData);
} catch (error) {
console.error("Error loading measurement config data:", error);
res.status(500).send(`// Failed to load config data: ${error.message}`);
}
});
// Register the measurement node and its menu data endpoint
console.log('Measurement node and its menu data endpoint are registered.');
};

167
src/nodeClass.js Normal file
View File

@@ -0,0 +1,167 @@
/**
* measurement.class.js
*
* Encapsulates all Measurement node logic in a reusable class.
*/
const { outputUtils, configManager } = require('generalFunctions');
const Measurement = require("../dependencies/measurement/measurement");
/**
* Class representing a Measurement Node-RED node.
*/
class MeasurementNode {
/**
* Create a MeasurementNode.
* @param {object} config - Node-RED node configuration.
* @param {object} RED - Node-RED runtime API.
*/
constructor(config, RED, nodeInstance) {
// Preserve RED reference for HTTP endpoints if needed
this.node = nodeInstance;
this.RED = RED;
// Load default & UI config
this._loadConfig(config);
// Instantiate core Measurement class
this._setupMeasurementClass();
// 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) {
const cfgMgr = new configManager();
this.defaultConfig = cfgMgr.getConfig("measurement");
// Merge UI config over defaults
this.config = {
general: {
name: uiConfig.name,
id: this.id,
unit: uiConfig.unit,
logging: {
enabled: uiConfig.enableLog,
logLevel: uiConfig.logLevel
}
},
asset: {
tagCode: uiConfig.assetTagCode,
supplier: uiConfig.supplier,
subType: uiConfig.subType,
model: uiConfig.model
},
scaling: {
enabled: uiConfig.scaling,
inputMin: uiConfig.i_min,
inputMax: uiConfig.i_max,
absMin: uiConfig.o_min,
absMax: uiConfig.o_max,
offset: uiConfig.i_offset
},
smoothing: {
smoothWindow: uiConfig.count,
smoothMethod: uiConfig.smooth_method
},
simulation: {
enabled: uiConfig.simulator
}
};
// Utility for formatting outputs
this._output = new outputUtils();
}
/**
* Instantiate the core Measurement logic and store as source.
*/
_setupMeasurementClass() {
this.source = new Measurement(this.config);
}
/**
* Bind Measurement events to Node-RED status 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.id, positionVsParent: 'upstream' }
]);
}, 100);
}
/**
* Start the periodic tick loop to drive the Measurement class.
*/
_startTickLoop() {
setTimeout(() => {
this._tickInterval = setInterval(() => this._tick(), 1000);
}, 1000);
}
/**
* Execute a single tick: update measurement, format and send outputs.
*/
_tick() {
this.source.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 Measurement class.
*/
_attachInputHandler() {
this.node.on('input', (msg, send, done) => {
switch (msg.topic) {
case 'simulator': this.source.toggleSimulation(); break;
case 'outlierDetection': this.source.toggleOutlierDetection(); break;
case 'calibrate': this.source.calibrate(); break;
case 'measurement':
if (typeof msg.payload === 'number') {
this.source.inputValue = parseFloat(msg.payload);
}
break;
}
done();
});
}
/**
* Clean up timers and intervals when Node-RED stops the node.
*/
_attachCloseHandler() {
this.node.on('close', (done) => {
clearInterval(this._tickInterval);
done();
});
}
}
module.exports = MeasurementNode;