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

Compare commits

base: RnD:main
Branches Tags
RnD:main RnD:dev-Rene RnD:dev-Pieter
...
compare: RnD:f2c9134b64e86138ca3dcb66f87e1478f2782b2a
Branches Tags
RnD:dev-Rene RnD:main RnD:dev-Pieter

9 Commits
main ... f2c9134b64

Author SHA1 Message Date
znetsixe
f2c9134b64 Added new menu jsons 2025-11-13 19:39:48 +01:00
znetsixe
5df3881375 added gravity function for calculating local g updated config for faster testing and changed the symbols at physical pos 2025-11-12 17:39:39 +01:00
znetsixe
6be3bf92ef first creation of PID controller + adjustments to pumpingstation 2025-11-10 13:41:41 +01:00
znetsixe
efe4a5f97d update flow arrow 2025-11-07 15:30:24 +01:00
znetsixe
e5c98b7d30 removed some old comments, added thresholds for safeguard 2025-11-07 15:09:35 +01:00
znetsixe
4a489acd89 some formatting 2025-11-06 16:47:17 +01:00
znetsixe
98cd44d3ae updated output utils bug fixes for formatting 2025-11-06 11:18:54 +01:00
znetsixe
44adfdece6 removed caps sensitivity 2025-11-05 17:15:32 +01:00
znetsixe
9ada6e2acd Added support for maintenance tracking in hours. "getMaintenanceTimeHours" default in output of machine now 2025-11-05 15:47:05 +01:00
30 changed files with 5048 additions and 304 deletions
Expand all files Collapse all files

1
datasets/assetData/assetData.json
View File

@@ -83,6 +83,7 @@
{ {
"id": "hidrostal-pump-001", "id": "hidrostal-pump-001",
"name": "hidrostal-H05K-S03R", "name": "hidrostal-H05K-S03R",
"units": ["l/s"] "units": ["l/s"]
}, },
{ {

89
datasets/assetData/index.js Normal file
View File

@@ -0,0 +1,89 @@
const fs = require('fs');
const path = require('path');
class AssetCategoryManager {
constructor(relPath = '.') {
this.assetDir = path.resolve(__dirname, relPath);
this.cache = new Map();
}
getCategory(softwareType) {
if (!softwareType) {
throw new Error('softwareType is required');
}
if (this.cache.has(softwareType)) {
return this.cache.get(softwareType);
}
const filePath = path.resolve(this.assetDir, `${softwareType}.json`);
if (!fs.existsSync(filePath)) {
throw new Error(`Asset data '${softwareType}' not found in ${this.assetDir}`);
}
const raw = fs.readFileSync(filePath, 'utf8');
const parsed = JSON.parse(raw);
this.cache.set(softwareType, parsed);
return parsed;
}
hasCategory(softwareType) {
const filePath = path.resolve(this.assetDir, `${softwareType}.json`);
return fs.existsSync(filePath);
}
listCategories({ withMeta = false } = {}) {
const files = fs.readdirSync(this.assetDir, { withFileTypes: true });
return files
.filter(
(entry) =>
entry.isFile() &&
entry.name.endsWith('.json') &&
entry.name !== 'index.json' &&
entry.name !== 'assetData.json'
)
.map((entry) => path.basename(entry.name, '.json'))
.map((name) => {
if (!withMeta) {
return name;
}
const data = this.getCategory(name);
return {
softwareType: data.softwareType || name,
label: data.label || name,
file: `${name}.json`
};
});
}
searchCategories(query) {
const term = (query || '').trim().toLowerCase();
if (!term) {
return [];
}
return this.listCategories({ withMeta: true }).filter(
({ softwareType, label }) =>
softwareType.toLowerCase().includes(term) ||
label.toLowerCase().includes(term)
);
}
clearCache() {
this.cache.clear();
}
}
const assetCategoryManager = new AssetCategoryManager();
module.exports = {
AssetCategoryManager,
assetCategoryManager,
getCategory: (softwareType) => assetCategoryManager.getCategory(softwareType),
listCategories: (options) => assetCategoryManager.listCategories(options),
searchCategories: (query) => assetCategoryManager.searchCategories(query),
hasCategory: (softwareType) => assetCategoryManager.hasCategory(softwareType),
clearCache: () => assetCategoryManager.clearCache()
};

21
datasets/assetData/machine.json Normal file
View File

@@ -0,0 +1,21 @@
{
"id": "machine",
"label": "machine",
"softwareType": "machine",
"suppliers": [
{
"id": "hidrostal",
"name": "Hidrostal",
"types": [
{
"id": "pump-centrifugal",
"name": "Centrifugal",
"models": [
{ "id": "hidrostal-H05K-S03R", "name": "hidrostal-H05K-S03R", "units": ["l/s","m3/h"] },
{ "id": "hidrostal-C5-D03R-SHN1", "name": "hidrostal-C5-D03R-SHN1", "units": ["l/s"] }
]
}
]
}
]
}

52
datasets/assetData/measurement.json Normal file
View File

@@ -0,0 +1,52 @@
{
"id": "sensor",
"label": "Sensor",
"softwareType": "measurement",
"suppliers": [
{
"id": "vega",
"name": "Vega",
"types": [
{
"id": "temperature",
"name": "Temperature",
"models": [
{ "id": "vega-temp-10", "name": "VegaTemp 10", "units": ["degC", "degF"] },
{ "id": "vega-temp-20", "name": "VegaTemp 20", "units": ["degC", "degF"] }
]
},
{
"id": "pressure",
"name": "Pressure",
"models": [
{ "id": "vega-pressure-10", "name": "VegaPressure 10", "units": ["bar", "mbar", "psi"] },
{ "id": "vega-pressure-20", "name": "VegaPressure 20", "units": ["bar", "mbar", "psi"] }
]
},
{
"id": "flow",
"name": "Flow",
"models": [
{ "id": "vega-flow-10", "name": "VegaFlow 10", "units": ["m3/h", "gpm", "l/min"] },
{ "id": "vega-flow-20", "name": "VegaFlow 20", "units": ["m3/h", "gpm", "l/min"] }
]
},
{
"id": "level",
"name": "Level",
"models": [
{ "id": "vega-level-10", "name": "VegaLevel 10", "units": ["m", "ft", "mm"] },
{ "id": "vega-level-20", "name": "VegaLevel 20", "units": ["m", "ft", "mm"] }
]
},
{
"id": "oxygen",
"name": "Quantity (oxygen)",
"models": [
{ "id": "vega-oxy-10", "name": "VegaOxySense 10", "units": ["g/m3", "mol/m3"] }
]
}
]
}
]
}

16
datasets/assetData/modelData/ECDV.json Normal file
View File

@@ -0,0 +1,16 @@
{
"1.204": {
"125": {
"x": [0,10,20,30,40,50,60,70,80,90,100],
"y": [0,18,50,95,150,216,337,564,882,1398,1870]
},
"150": {
"x": [0,10,20,30,40,50,60,70,80,90,100],
"y": [0,25,73,138,217,314,490,818,1281,2029,2715]
},
"400": {
"x": [0,10,20,30,40,50,60,70,80,90,100],
"y": [0,155,443,839,1322,1911,2982,4980,7795,12349,16524]
}
}
}

838
datasets/assetData/modelData/hidrostal-C5-D03R-SHN1.json Normal file
View File

@@ -0,0 +1,838 @@
{
"np": {
"400": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5953611390998625,
1.6935085477165994,
3.801139124304824,
7.367829525776738,
12.081735423116616
]
},
"500": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.8497068236812997,
3.801139124304824,
7.367829525776738,
12.081735423116616
]
},
"600": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.7497197821018213,
3.801139124304824,
7.367829525776738,
12.081735423116616
]
},
"700": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.788320579602724,
3.9982668237045984,
7.367829525776738,
12.081735423116616
]
},
"800": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.7824519364844427,
3.9885060367793064,
7.367829525776738,
12.081735423116616
]
},
"900": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6934482683506376,
3.9879559558537054,
7.367829525776738,
12.081735423116616
]
},
"1000": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6954385513069579,
4.0743508382926795,
7.422392692482345,
12.081735423116616
]
},
"1100": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
4.160745720731654,
7.596626714476177,
12.081735423116616
]
},
"1200": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
4.302551231007837,
7.637247864947884,
12.081735423116616
]
},
"1300": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
4.37557913990704,
7.773442147000839,
12.081735423116616
]
},
"1400": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
4.334434337766139,
7.940911352646818,
12.081735423116616
]
},
"1500": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
4.2327206586037995,
8.005238800611183,
12.254836577088351
]
},
"1600": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
4.195405588464695,
7.991827302945298,
12.423663269044452
]
},
"1700": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
14.255458319309813,
8.096768422220196,
12.584668380908582
]
},
"1800": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
31.54620347513727,
12.637080520201405
]
},
"1900": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
8.148423429611098,
12.74916725120127
]
},
"2000": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
8.146439484120116,
12.905178964345618
]
},
"2100": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
8.149576025637684,
13.006940917309247
]
},
"2200": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
8.126246430368305,
13.107503837410825
]
},
"2300": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
8.104379361635342,
13.223235973280122
]
},
"2400": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
8.135190080423746,
13.36128347785936
]
},
"2500": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
7.981219508598527,
13.473697427231842
]
},
"2600": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
7.863899404441271,
13.50303289156837
]
},
"2700": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
7.658860522528131,
13.485230880073107
]
},
"2800": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
7.44407948309266,
13.446135725634615
]
},
"2900": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
0.5522732775894703,
1.6920721090317592,
3.8742719210788685,
7.44407948309266,
13.413693596332184
]
}
},
"nq": {
"400": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
7.6803204433986965,
25.506609120436963,
35.4,
44.4,
52.5
]
},
"500": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
22.622804921188227,
35.4,
44.4,
52.5
]
},
"600": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
19.966301579194372,
35.4,
44.4,
52.5
]
},
"700": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
17.430763940163832,
33.79508340848005,
44.4,
52.5
]
},
"800": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
14.752921911234477,
31.71885034449889,
44.4,
52.5
]
},
"900": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
11.854693031181021,
29.923046639543475,
44.4,
52.5
]
},
"1000": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.549433913822687,
26.734189128096668,
43.96760750800311,
52.5
]
},
"1100": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
26.26933164936586,
42.23523193272671,
52.5
]
},
"1200": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
24.443114637042832,
40.57167959798151,
52.5
]
},
"1300": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
22.41596168949836,
39.04561852479495,
52.5
]
},
"1400": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
20.276864821170303,
37.557663261443224,
52.252852231224054
]
},
"1500": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
18.252772588147742,
35.9974418607538,
50.68604059588987
]
},
"1600": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
16.31441663648616,
34.51170378091407,
49.20153034100798
]
},
"1700": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
14.255458319309813,
33.043410795291045,
47.820213744181245
]
},
"1800": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
31.54620347513727,
46.51705619739449
]
},
"1900": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
29.986013742375484,
45.29506741639918
]
},
"2000": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
28.432646044605782,
44.107822395271945
]
},
"2100": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
26.892634464336055,
42.758175515158776
]
},
"2200": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
25.270679127870263,
41.467063889795895
]
},
"2300": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
23.531132157718837,
40.293041104955826
]
},
"2400": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
21.815645106750623,
39.03109248860755
]
},
"2500": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
20.34997949463564,
37.71320701654063
]
},
"2600": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
18.81710568651804,
36.35563657017404
]
},
"2700": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
17.259072160217805,
35.02979557646653
]
},
"2800": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
16,
33.74372254979665
]
},
"2900": {
"x": [
0,
25.510204081632654,
51.020408163265309,
76.530612244897952,
100
],
"y": [
6.4,
9.500000000000002,
12.7,
16,
32.54934541379723
]
}
}
}

1062
datasets/assetData/modelData/hidrostal-H05K-S03R.json Normal file
View File

File diff suppressed because it is too large Load Diff

124
datasets/assetData/modelData/index.js Normal file
View File

@@ -0,0 +1,124 @@
const fs = require('fs');
const path = require('path');
class AssetLoader {
constructor() {
this.relPath = './'
this.baseDir = path.resolve(__dirname, this.relPath);
this.cache = new Map(); // Cache loaded JSON files for better performance
}
/**
* Load a specific curve by type
* @param {string} curveType - The curve identifier (e.g., 'hidrostal-H05K-S03R')
* @returns {Object|null} The curve data object or null if not found
*/
loadModel(modelType) {
return this.loadAsset('models', modelType);
}
/**
* Load any asset from a specific dataset folder
* @param {string} datasetType - The dataset folder name (e.g., 'curves', 'assetData')
* @param {string} assetId - The specific asset identifier
* @returns {Object|null} The asset data object or null if not found
*/
loadAsset(datasetType, assetId) {
//const cacheKey = `${datasetType}/${assetId}`;
const cacheKey = `${assetId}`;
// Check cache first
if (this.cache.has(cacheKey)) {
return this.cache.get(cacheKey);
}
try {
const filePath = path.join(this.baseDir, `${assetId}.json`);
// Check if file exists
if (!fs.existsSync(filePath)) {
console.warn(`Asset not found: ${filePath}`);
return null;
}
// Load and parse JSON
const rawData = fs.readFileSync(filePath, 'utf8');
const assetData = JSON.parse(rawData);
// Cache the result
this.cache.set(cacheKey, assetData);
return assetData;
} catch (error) {
console.error(`Error loading asset ${cacheKey}:`, error.message);
return null;
}
}
/**
* Get all available assets in a dataset
* @param {string} datasetType - The dataset folder name
* @returns {string[]} Array of available asset IDs
*/
getAvailableAssets(datasetType) {
try {
const datasetPath = path.join(this.baseDir, datasetType);
if (!fs.existsSync(datasetPath)) {
return [];
}
return fs.readdirSync(datasetPath)
.filter(file => file.endsWith('.json'))
.map(file => file.replace('.json', ''));
} catch (error) {
console.error(`Error reading dataset ${datasetType}:`, error.message);
return [];
}
}
/**
* Clear the cache (useful for development/testing)
*/
clearCache() {
this.cache.clear();
}
}
// Create and export a singleton instance
const assetLoader = new AssetLoader();
module.exports = {
AssetLoader,
assetLoader,
// Convenience methods for backward compatibility
loadModel: (modelType) => assetLoader.loadModel(modelType),
loadAsset: (datasetType, assetId) => assetLoader.loadAsset(datasetType, assetId),
getAvailableAssets: (datasetType) => assetLoader.getAvailableAssets(datasetType)
};
/*
// Example usage in your scripts
const loader = new AssetLoader();
// Load a specific curve
const curve = loader.loadModel('hidrostal-H05K-S03R');
if (curve) {
console.log('Model loaded:', curve);
} else {
console.log('Model not found');
}
/*
// Load any asset from any dataset
const someAsset = loadAsset('assetData', 'some-asset-id');
// Get list of available models
const availableCurves = getAvailableAssets('curves');
console.log('Available curves:', availableCurves);
// Using the class directly for more control
const { AssetLoader } = require('./index.js');
const customLoader = new AssetLoader();
const data = customLoader.loadCurve('hidrostal-H05K-S03R');
*/

27
datasets/assetData/valve.json Normal file
View File

@@ -0,0 +1,27 @@
{
"id": "valve",
"label": "valve",
"softwareType": "valve",
"suppliers": [
{
"id": "binder",
"name": "Binder Engineering",
"types": [
{
"id": "valve-gate",
"name": "Gate",
"models": [
{ "id": "binder-valve-001", "name": "ECDV", "units": ["m3/h", "gpm", "l/min"] }
]
},
{
"id": "valve-jet",
"name": "Jet",
"models": [
{ "id": "binder-valve-002", "name": "JCV", "units": ["m3/h", "gpm", "l/min"] }
]
}
]
}
]
}

1363
datasets/tagcodeapp_assets.json
View File

File diff suppressed because one or more lines are too long

8
index.js
View File

@@ -14,6 +14,7 @@ const validation = require('./src/helper/validationUtils.js');
const configUtils = require('./src/helper/configUtils.js'); const configUtils = require('./src/helper/configUtils.js');
const assertions = require('./src/helper/assertionUtils.js') const assertions = require('./src/helper/assertionUtils.js')
const coolprop = require('./src/coolprop-node/src/index.js'); const coolprop = require('./src/coolprop-node/src/index.js');
const gravity = require('./src/helper/gravity.js')
// Domain-specific modules // Domain-specific modules
const { MeasurementContainer } = require('./src/measurements/index.js'); const { MeasurementContainer } = require('./src/measurements/index.js');
@@ -25,7 +26,8 @@ const MenuManager = require('./src/menu/index.js');
const predict = require('./src/predict/predict_class.js'); const predict = require('./src/predict/predict_class.js');
const interpolation = require('./src/predict/interpolation.js'); const interpolation = require('./src/predict/interpolation.js');
const childRegistrationUtils = require('./src/helper/childRegistrationUtils.js'); const childRegistrationUtils = require('./src/helper/childRegistrationUtils.js');
const { loadCurve } = require('./datasets/assetData/curves/index.js'); const { loadCurve } = require('./datasets/assetData/curves/index.js'); //deprecated replace with load model data
const { loadModel } = require('./datasets/assetData/modelData/index.js');
// Export everything // Export everything
module.exports = { module.exports = {
@@ -44,5 +46,7 @@ module.exports = {
convert, convert,
MenuManager, MenuManager,
childRegistrationUtils, childRegistrationUtils,
loadCurve loadCurve, //deprecated replace with loadModel
loadModel,
gravity
}; };

226
src/configs/pumpingStation.json
View File

@@ -348,13 +348,13 @@
} }
}, },
"control": { "control": {
"controlStrategy": { "mode": {
"default": "levelBased", "default": "levelbased",
"rules": { "rules": {
"type": "enum", "type": "string",
"values": [ "values": [
{ {
"value": "levelBased", "value": "levelbased",
"description": "Lead and lag pumps are controlled by basin level thresholds." "description": "Lead and lag pumps are controlled by basin level thresholds."
}, },
{ {
@@ -362,9 +362,21 @@
"description": "Pumps target a discharge pressure setpoint." "description": "Pumps target a discharge pressure setpoint."
}, },
{ {
"value": "flowTracking", "value": "flowBased",
"description": "Pumps modulate to match measured inflow or downstream demand." "description": "Pumps modulate to match measured inflow or downstream demand."
}, },
{
"value": "percentageBased",
"description": "Pumps operate to maintain basin volume at a target percentage."
},
{
"value":"powerBased",
"description": "Pumps are controlled based on power consumption.For example, to limit peak power usage or operate within netcongestion limits."
},
{
"value": "hybrid",
"description": "Combines multiple control strategies for optimized operation."
},
{ {
"value": "manual", "value": "manual",
"description": "Pumps are operated manually or by an external controller." "description": "Pumps are operated manually or by an external controller."
@@ -373,80 +385,50 @@
"description": "Primary control philosophy for pump actuation." "description": "Primary control philosophy for pump actuation."
} }
}, },
"levelSetpoints": { "allowedModes": {
"default": { "default": [
"startLeadPump": 1.2, "levelbased",
"stopLeadPump": 0.8, "pressurebased",
"startLagPump": 1.8, "flowbased",
"stopLagPump": 1.4, "percentagebased",
"alarmHigh": 2.3, "powerbased",
"alarmLow": 0.3 "manual"
}, ],
"rules": { "rules": {
"type": "object", "type": "set",
"description": "Level thresholds that govern pump staging and alarms (m).", "itemType": "string",
"schema": { "description": "List of control modes that the station is permitted to operate in."
"startLeadPump": {
"default": 1.2,
"rules": {
"type": "number",
"description": "Level that starts the lead pump."
} }
}, },
"stopLeadPump": { "levelbased": {
"default": 0.8, "thresholds": {
"default": [30,40,50,60,70,80,90],
"rules": { "rules": {
"type": "number", "type": "array",
"description": "Level that stops the lead pump." "description": "Each time a threshold is overwritten a new pump can start or kick into higher gear. Volume thresholds (%) in ascending order used for level-based control."
} }
}, },
"startLagPump": { "timeThresholdSeconds": {
"default": 1.8, "default": 5,
"rules": {
"type": "number",
"description": "Level that starts the lag pump."
}
},
"stopLagPump": {
"default": 1.4,
"rules": {
"type": "number",
"description": "Level that stops the lag pump."
}
},
"alarmHigh": {
"default": 2.3,
"rules": {
"type": "number",
"description": "High level alarm threshold."
}
},
"alarmLow": {
"default": 0.3,
"rules": {
"type": "number",
"description": "Low level alarm threshold."
}
}
}
}
},
"pressureSetpoint": {
"default": 250,
"rules": { "rules": {
"type": "number", "type": "number",
"min": 0, "min": 0,
"description": "Duration the volume condition must persist before triggering pump actions (seconds)."
}
}
},
"pressureBased": {
"pressureSetpoint": {
"default": 1000,
"rules": {
"type": "number",
"min": 0,
"max": 5000,
"description": "Target discharge pressure when operating in pressure control (kPa)." "description": "Target discharge pressure when operating in pressure control (kPa)."
} }
},
"alarmDebounceSeconds": {
"default": 10,
"rules": {
"type": "number",
"min": 0,
"description": "Time a condition must persist before raising an alarm (seconds)."
} }
}, },
"flowBased": {
"equalizationTargetPercent": { "equalizationTargetPercent": {
"default": 60, "default": 60,
"rules": { "rules": {
@@ -456,11 +438,59 @@
"description": "Target fill percentage of the basin when operating in equalization mode." "description": "Target fill percentage of the basin when operating in equalization mode."
} }
}, },
"autoRestartAfterPowerLoss": { "flowBalanceTolerance": {
"default": true, "default": 5,
"rules": { "rules": {
"type": "boolean", "type": "number",
"description": "If true, pumps resume based on last known state after power restoration." "min": 0,
"description": "Allowable error between inflow and outflow before adjustments are triggered (m3/h)."
}
}
},
"percentageBased": {
"targetVolumePercent": {
"default": 50,
"rules": {
"type": "number",
"min": 0,
"max": 100,
"description": "Target basin volume percentage to maintain during percentage-based control."
}
},
"tolerancePercent": {
"default": 5,
"rules": {
"type": "number",
"min": 0,
"description": "Acceptable deviation from the target volume percentage before corrective action is taken."
}
}
},
"powerBased": {
"maxPowerKW": {
"default": 50,
"rules": {
"type": "number",
"min": 0,
"description": "Maximum allowable power consumption for the pumping station (kW)."
}
},
"powerControlMode": {
"default": "limit",
"rules": {
"type": "enum",
"values": [
{
"value": "limit",
"description": "Limit pump operation to stay below the max power threshold."
},
{
"value": "optimize",
"description": "Optimize pump scheduling to minimize power usage while meeting flow demands."
}
],
"description": "Defines how power constraints are managed during operation."
}
} }
}, },
"manualOverrideTimeoutMinutes": { "manualOverrideTimeoutMinutes": {
@@ -470,13 +500,63 @@
"min": 0, "min": 0,
"description": "Duration after which a manual override expires automatically (minutes)." "description": "Duration after which a manual override expires automatically (minutes)."
} }
}
}, },
"flowBalanceTolerance": { "safety": {
"default": 5, "enableDryRunProtection": {
"default": true,
"rules": {
"type": "boolean",
"description": "If true, pumps will be prevented from running if basin volume is too low."
}
},
"dryRunThresholdPercent": {
"default": 2,
"rules": { "rules": {
"type": "number", "type": "number",
"min": 0, "min": 0,
"description": "Allowable error between inflow and outflow before adjustments are triggered (m3/h)." "max": 100,
"description": "Volume percentage below which dry run protection activates."
}
},
"dryRunDebounceSeconds": {
"default": 30,
"rules": {
"type": "number",
"min": 0,
"description": "Time the low-volume condition must persist before dry-run protection engages (seconds)."
}
},
"enableOverfillProtection": {
"default": true,
"rules": {
"type": "boolean",
"description": "If true, high level alarms and shutdowns will be enforced to prevent overfilling."
}
},
"overfillThresholdPercent": {
"default": 98,
"rules": {
"type": "number",
"min": 0,
"max": 100,
"description": "Volume percentage above which overfill protection activates."
}
},
"overfillDebounceSeconds": {
"default": 30,
"rules": {
"type": "number",
"min": 0,
"description": "Time the high-volume condition must persist before overfill protection engages (seconds)."
}
},
"timeleftToFullOrEmptyThresholdSeconds": {
"default": 120,
"rules": {
"type": "number",
"min": 0,
"description": "Time threshold (seconds) used to predict imminent full or empty conditions."
} }
} }
}, },

53
src/configs/rotatingMachine.json
View File

@@ -245,10 +245,6 @@
{ {
"value": "fysicalControl", "value": "fysicalControl",
"description": "Controlled via physical buttons or switches; ignores external automated commands." "description": "Controlled via physical buttons or switches; ignores external automated commands."
},
{
"value": "maintenance",
"description": "No active control from auto, virtual, or fysical sources."
} }
], ],
"description": "The operational mode of the machine." "description": "The operational mode of the machine."
@@ -260,7 +256,14 @@
"type": "object", "type": "object",
"schema":{ "schema":{
"auto": { "auto": {
"default": ["statusCheck", "execMovement", "execSequence", "emergencyStop"], "default": [
"statuscheck",
"execmovement",
"execsequence",
"flowmovement",
"emergencystop",
"entermaintenance"
],
"rules": { "rules": {
"type": "set", "type": "set",
"itemType": "string", "itemType": "string",
@@ -268,7 +271,14 @@
} }
}, },
"virtualControl": { "virtualControl": {
"default": ["statusCheck", "execMovement", "execSequence", "emergencyStop"], "default": [
"statuscheck",
"execmovement",
"flowmovement",
"execsequence",
"emergencystop",
"exitmaintenance"
],
"rules": { "rules": {
"type": "set", "type": "set",
"itemType": "string", "itemType": "string",
@@ -276,24 +286,21 @@
} }
}, },
"fysicalControl": { "fysicalControl": {
"default": ["statusCheck", "emergencyStop"], "default": [
"statuscheck",
"emergencystop",
"entermaintenance",
"exitmaintenance"
],
"rules": { "rules": {
"type": "set", "type": "set",
"itemType": "string", "itemType": "string",
"description": "Actions allowed in fysicalControl mode." "description": "Actions allowed in fysicalControl mode."
} }
},
"maintenance": {
"default": ["statusCheck"],
"rules": {
"type": "set",
"itemType": "string",
"description": "Actions allowed in maintenance mode."
} }
} }
}, },
"description": "Information about valid command sources recognized by the machine." "description": "Information about valid command sources recognized by the machine."
}
}, },
"allowedSources":{ "allowedSources":{
"default": {}, "default": {},
@@ -386,6 +393,22 @@
"itemType": "string", "itemType": "string",
"description": "Sequence of states for booting up the machine." "description": "Sequence of states for booting up the machine."
} }
},
"entermaintenance":{
"default": ["stopping","coolingdown","idle","maintenance"],
"rules": {
"type": "set",
"itemType": "string",
"description": "Sequence of states if the machine is running to put it in maintenance state"
}
},
"exitmaintenance":{
"default": ["off","idle"],
"rules": {
"type": "set",
"itemType": "string",
"description": "Sequence of states if the machine is running to put it in maintenance state"
}
} }
} }
}, },

76
src/coolprop-node/src/index.js
View File

@@ -3,11 +3,61 @@ const customRefs = require('./refData.js');
class CoolPropWrapper { class CoolPropWrapper {
constructor() { constructor() {
this.initialized = false; this.initialized = false;
this.defaultRefrigerant = null; this.defaultRefrigerant = null;
this.defaultTempUnit = 'K'; // K, C, F this.defaultTempUnit = 'K'; // K, C, F
this.defaultPressureUnit = 'Pa' // Pa, kPa, bar, psi this.defaultPressureUnit = 'Pa' // Pa, kPa, bar, psi
this.customRef = false; this.customRef = false;
this.PropsSI = this._propsSI.bind(this);
// 🔹 Wastewater correction options (defaults)
this._ww = {
enabled: true,
tss_g_per_L: 3.5, // default MLSS / TSS
density_k: 2e-4, // +0.02% per g/L
viscosity_k: 0.07, // +7% per g/L (clamped)
viscosity_max_gpl: 4 // cap effect at 4 g/L
};
this._initPromise = null;
this._autoInit({ refrigerant: 'Water' });
}
_isWastewaterFluid(fluidRaw) {
if (!fluidRaw) return false;
const token = String(fluidRaw).trim().toLowerCase();
return token === 'wastewater' || token.startsWith('wastewater:');
}
_parseWastewaterFluid(fluidRaw) {
if (!this._isWastewaterFluid(fluidRaw)) return null;
const ww = { ...this._ww };
const [, tail] = String(fluidRaw).split(':');
if (tail) {
tail.split(',').forEach(pair => {
const [key, value] = pair.split('=').map(s => s.trim().toLowerCase());
if (key === 'tss' && !Number.isNaN(Number(value))) {
ww.tss_g_per_L = Number(value);
}
});
}
return ww;
}
_applyWastewaterCorrection(outputKey, baseValue, ww) {
if (!Number.isFinite(baseValue) || !ww || !ww.enabled) return baseValue;
switch (outputKey.toUpperCase()) {
case 'D': // density
return baseValue * (1 + ww.density_k * ww.tss_g_per_L);
case 'V': // viscosity
const effTss = Math.min(ww.tss_g_per_L, ww.viscosity_max_gpl);
return baseValue * (1 + ww.viscosity_k * effTss);
default:
return baseValue;
}
} }
// Temperature conversion helpers // Temperature conversion helpers
@@ -407,13 +457,31 @@ class CoolPropWrapper {
} }
} }
// Direct access to CoolProp functions _autoInit(defaults) {
async getPropsSI() { if (!this._initPromise) {
this._initPromise = this.init(defaults);
}
return this._initPromise;
}
_propsSI(outputKey, inKey1, inVal1, inKey2, inVal2, fluidRaw) {
if (!this.initialized) { if (!this.initialized) {
await coolprop.init(); // Start init if no one else asked yet
this._autoInit({ refrigerant: this.defaultRefrigerant || 'Water' });
throw new Error('CoolProp is still warming up, retry PropsSI in a moment');
} }
return coolprop.PropsSI; const ww = this._parseWastewaterFluid(fluidRaw);
const fluid = ww ? 'Water' : (this.customRefString || fluidRaw);
const baseValue = coolprop.PropsSI(outputKey, inKey1, inVal1, inKey2, inVal2, fluid);
return ww ? this._applyWastewaterCorrection(outputKey, baseValue, ww) : baseValue;
} }
//Access to coolprop
async getPropsSI() {
await this._ensureInit({ refrigerant: this.defaultRefrigerant || 'Water' });
return this.PropsSI;
}
} }
module.exports = new CoolPropWrapper(); module.exports = new CoolPropWrapper();

90
src/helper/gravity.js Normal file
View File

@@ -0,0 +1,90 @@
/**
* Gravity calculations based on WGS-84 ellipsoid model.
* Author: Rene de Ren (Waterschap Brabantse Delta)
* License: EUPL-1.2
*/
class Gravity {
constructor() {
// Standard (conventional) gravity at 45° latitude, sea level
this.g0 = 9.80665; // m/s²
}
/**
* Returns standard gravity (constant)
* @returns {number} gravity in m/s²
*/
getStandardGravity() {
return this.g0;
}
/**
* Computes local gravity based on latitude and elevation.
* Formula: WGS-84 normal gravity (Somigliana)
* @param {number} latitudeDeg Latitude in degrees (−90 → +90)
* @param {number} elevationM Elevation above sea level [m]
* @returns {number} gravity in m/s²
*/
getLocalGravity(latitudeDeg, elevationM = 0) {
const phi = (latitudeDeg * Math.PI) / 180;
const sinPhi = Math.sin(phi);
const sin2 = sinPhi * sinPhi;
const sin2_2phi = Math.sin(2 * phi) ** 2;
// WGS-84 normal gravity on the ellipsoid
const gSurface =
9.780327 * (1 + 0.0053024 * sin2 - 0.0000058 * sin2_2phi);
// Free-air correction for elevation (~ −3.086×10⁻⁶ m/s² per m)
const gLocal = gSurface - 3.086e-6 * elevationM;
return gLocal;
}
/**
* Calculates hydrostatic pressure difference (ΔP = ρ g h)
* @param {number} density Fluid density [kg/m³]
* @param {number} heightM Height difference [m]
* @param {number} latitudeDeg Latitude (for local g)
* @param {number} elevationM Elevation (for local g)
* @returns {number} Pressure difference [Pa]
*/
pressureHead(density, heightM, latitudeDeg = 45, elevationM = 0) {
const g = this.getLocalGravity(latitudeDeg, elevationM);
return density * g * heightM;
}
/**
* Calculates weight force (F = m g)
* @param {number} massKg Mass [kg]
* @param {number} latitudeDeg Latitude (for local g)
* @param {number} elevationM Elevation (for local g)
* @returns {number} Force [N]
*/
weightForce(massKg, latitudeDeg = 45, elevationM = 0) {
const g = this.getLocalGravity(latitudeDeg, elevationM);
return massKg * g;
}
}
module.exports = new Gravity();
/*
const gravity = gravity;
// Standard gravity
console.log('g₀ =', gravity.getStandardGravity(), 'm/s²');
// Local gravity (Breda ≈ 51.6° N, 3 m elevation)
console.log('g @ Breda =', gravity.getLocalGravity(51.6, 3).toFixed(6), 'm/s²');
// Head pressure for 5 m water column at Breda
console.log(
'ΔP =',
gravity.pressureHead(1000, 5, 51.6, 3).toFixed(1),
'Pa'
);
// Weight of 1 kg mass at Breda
console.log('Weight =', gravity.weightForce(1, 51.6, 3).toFixed(6), 'N');
*/

5
src/helper/menuUtils.js
View File

@@ -180,7 +180,6 @@ async apiCall(node) {
// Only add tagCode to URL if it exists // Only add tagCode to URL if it exists
if (tagCode) { if (tagCode) {
apiUrl += `&asset_tag_number=${tagCode}`; apiUrl += `&asset_tag_number=${tagCode}`;
console.log('hello there');
} }
assetregisterAPI += apiUrl; assetregisterAPI += apiUrl;
@@ -461,10 +460,6 @@ populateModels(
// Store only the metadata for the selected model // Store only the metadata for the selected model
node["modelMetadata"] = modelData.find((model) => model.name === selectedModel); node["modelMetadata"] = modelData.find((model) => model.name === selectedModel);
}); });
/*
console.log('hello here I am:');
console.log(node["modelMetadata"]);
*/
}); });
}) })

6
src/helper/menuUtils_DEPRECATED.js
View File

@@ -180,7 +180,6 @@ async apiCall(node) {
// Only add tagCode to URL if it exists // Only add tagCode to URL if it exists
if (tagCode) { if (tagCode) {
apiUrl += `&asset_tag_number=${tagCode}`; apiUrl += `&asset_tag_number=${tagCode}`;
console.log('hello there');
} }
assetregisterAPI += apiUrl; assetregisterAPI += apiUrl;
@@ -461,10 +460,7 @@ populateModels(
// Store only the metadata for the selected model // Store only the metadata for the selected model
node["modelMetadata"] = modelData.find((model) => model.name === selectedModel); node["modelMetadata"] = modelData.find((model) => model.name === selectedModel);
}); });
/*
console.log('hello here I am:');
console.log(node["modelMetadata"]);
*/
}); });
}) })

11
src/helper/outputUtils.js
View File

@@ -64,7 +64,7 @@ class OutputUtils {
influxDBFormat(changedFields, config , flatTags) { influxDBFormat(changedFields, config , flatTags) {
// Create the measurement and topic using softwareType and name config.functionality.softwareType + . // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
const measurement = config.general.name; const measurement = `${config.functionality?.softwareType}_${config.general?.id}`;
const payload = { const payload = {
measurement: measurement, measurement: measurement,
fields: changedFields, fields: changedFields,
@@ -104,24 +104,23 @@ class OutputUtils {
return { return {
// general properties // general properties
id: config.general?.id, id: config.general?.id,
name: config.general?.name,
unit: config.general?.unit,
// functionality properties // functionality properties
softwareType: config.functionality?.softwareType, softwareType: config.functionality?.softwareType,
role: config.functionality?.role, role: config.functionality?.role,
// asset properties (exclude machineCurve) // asset properties (exclude machineCurve)
uuid: config.asset?.uuid, uuid: config.asset?.uuid,
tagcode: config.asset?.tagcode,
geoLocation: config.asset?.geoLocation, geoLocation: config.asset?.geoLocation,
supplier: config.asset?.supplier, category: config.asset?.category,
type: config.asset?.type, type: config.asset?.type,
subType: config.asset?.subType,
model: config.asset?.model, model: config.asset?.model,
unit: config.general?.unit,
}; };
} }
processFormat(changedFields,config) { processFormat(changedFields,config) {
// Create the measurement and topic using softwareType and name config.functionality.softwareType + . // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
const measurement = config.general.name; const measurement = `${config.functionality?.softwareType}_${config.general?.id}`;
const payload = changedFields; const payload = changedFields;
const topic = measurement; const topic = measurement;
const msg = { topic: topic, payload: payload }; const msg = { topic: topic, payload: payload };

2
src/measurements/Measurement.js
View File

@@ -113,7 +113,7 @@ class Measurement {
// Create a new measurement that is the difference between two positions // Create a new measurement that is the difference between two positions
static createDifference(upstreamMeasurement, downstreamMeasurement) { static createDifference(upstreamMeasurement, downstreamMeasurement) {
console.log('hello:');
if (upstreamMeasurement.type !== downstreamMeasurement.type || if (upstreamMeasurement.type !== downstreamMeasurement.type ||
upstreamMeasurement.variant !== downstreamMeasurement.variant) { upstreamMeasurement.variant !== downstreamMeasurement.variant) {
throw new Error('Cannot calculate difference between different measurement types or variants'); throw new Error('Cannot calculate difference between different measurement types or variants');

473
src/menu/asset.js
View File

@@ -1,61 +1,82 @@
// asset.js const { assetCategoryManager } = require('../../datasets/assetData');
const fs = require('fs');
const path = require('path');
class AssetMenu { class AssetMenu {
/** Define path where to find data of assets in constructor for now */ constructor({ manager = assetCategoryManager, softwareType = null } = {}) {
constructor(relPath = '../../datasets/assetData') { this.manager = manager;
this.baseDir = path.resolve(__dirname, relPath); this.softwareType = softwareType;
this.assetData = this._loadJSON('assetData'); this.categories = this.manager
.listCategories({ withMeta: true })
.reduce((map, meta) => {
map[meta.softwareType] = this.manager.getCategory(meta.softwareType);
return map;
}, {});
} }
_loadJSON(...segments) { normalizeCategory(key) {
const filePath = path.resolve(this.baseDir, ...segments) + '.json'; const category = this.categories[key];
try { if (!category) {
return JSON.parse(fs.readFileSync(filePath, 'utf8')); return null;
} catch (err) { }
throw new Error(`Failed to load ${filePath}: ${err.message}`);
return {
...category,
label: category.label || category.softwareType || key,
suppliers: (category.suppliers || []).map((supplier) => ({
...supplier,
id: supplier.id || supplier.name,
types: (supplier.types || []).map((type) => ({
...type,
id: type.id || type.name,
models: (type.models || []).map((model) => ({
...model,
id: model.id || model.name,
units: model.units || []
}))
}))
}))
};
}
resolveCategoryForNode(nodeName) {
const keys = Object.keys(this.categories);
if (keys.length === 0) {
return null;
}
if (this.softwareType && this.categories[this.softwareType]) {
return this.softwareType;
}
if (nodeName) {
const normalized = typeof nodeName === 'string' ? nodeName.toLowerCase() : nodeName;
if (normalized && this.categories[normalized]) {
return normalized;
} }
} }
/** return keys[0];
* ADD THIS METHOD }
* Compiles all menu data from the file system into a single nested object.
* This is run once on the server to pre-load everything. getAllMenuData(nodeName) {
* @returns {object} A comprehensive object with all menu options. const categoryKey = this.resolveCategoryForNode(nodeName);
*/ const selectedCategories = {};
getAllMenuData() {
// load the raw JSON once if (categoryKey && this.categories[categoryKey]) {
const data = this._loadJSON('assetData'); selectedCategories[categoryKey] = this.normalizeCategory(categoryKey);
const allData = {}; }
data.suppliers.forEach(sup => { return {
allData[sup.name] = {}; categories: selectedCategories,
sup.categories.forEach(cat => { defaultCategory: categoryKey
allData[sup.name][cat.name] = {}; };
cat.types.forEach(type => {
// here: store the full array of model objects, not just names
allData[sup.name][cat.name][type.name] = type.models;
});
});
});
return allData;
} }
/**
* Convert the static initEditor function to a string that can be served to the client
* @param {string} nodeName - The name of the node type
* @returns {string} JavaScript code as a string
*/
getClientInitCode(nodeName) { getClientInitCode(nodeName) {
// step 1: get the two helper strings
const htmlCode = this.getHtmlInjectionCode(nodeName); const htmlCode = this.getHtmlInjectionCode(nodeName);
const dataCode = this.getDataInjectionCode(nodeName); const dataCode = this.getDataInjectionCode(nodeName);
const eventsCode = this.getEventInjectionCode(nodeName); const eventsCode = this.getEventInjectionCode(nodeName);
const saveCode = this.getSaveInjectionCode(nodeName); const saveCode = this.getSaveInjectionCode(nodeName);
return ` return `
// --- AssetMenu for ${nodeName} --- // --- AssetMenu for ${nodeName} ---
window.EVOLV.nodes.${nodeName}.assetMenu = window.EVOLV.nodes.${nodeName}.assetMenu =
@@ -66,103 +87,276 @@ getClientInitCode(nodeName) {
${eventsCode} ${eventsCode}
${saveCode} ${saveCode}
// wire it all up when the editor loads
window.EVOLV.nodes.${nodeName}.assetMenu.initEditor = function(node) { window.EVOLV.nodes.${nodeName}.assetMenu.initEditor = function(node) {
// ------------------ BELOW sequence is important! ------------------------------- console.log('Initializing asset properties for ${nodeName}');
console.log('Initializing asset properties for ${nodeName}…');
this.injectHtml(); this.injectHtml();
// load the data and wire up events
// this will populate the fields and set up the event listeners
this.wireEvents(node); this.wireEvents(node);
// this will load the initial data into the fields
// this is important to ensure the fields are populated correctly
this.loadData(node); this.loadData(node);
}; };
`; `;
} }
getDataInjectionCode(nodeName) { getDataInjectionCode(nodeName) {
return ` return `
// Asset Data loader for ${nodeName} // Asset data loader for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.loadData = function(node) { window.EVOLV.nodes.${nodeName}.assetMenu.loadData = function(node) {
const data = window.EVOLV.nodes.${nodeName}.menuData.asset; const menuAsset = window.EVOLV.nodes.${nodeName}.menuData.asset || {};
const categories = menuAsset.categories || {};
const defaultCategory = menuAsset.defaultCategory || Object.keys(categories)[0] || null;
const elems = { const elems = {
supplier: document.getElementById('node-input-supplier'), supplier: document.getElementById('node-input-supplier'),
category: document.getElementById('node-input-category'),
type: document.getElementById('node-input-assetType'), type: document.getElementById('node-input-assetType'),
model: document.getElementById('node-input-model'), model: document.getElementById('node-input-model'),
unit: document.getElementById('node-input-unit') unit: document.getElementById('node-input-unit')
}; };
function populate(el, opts, sel) {
const old = el.value; function populate(selectEl, items = [], selectedValue, mapFn, placeholderText = 'Select...') {
el.innerHTML = '<option value="">Select…</option>'; const previous = selectEl.value;
(opts||[]).forEach(o=>{ const mapper = typeof mapFn === 'function'
const opt = document.createElement('option'); ? mapFn
opt.value = o; opt.textContent = o; : (value) => ({ value, label: value });
el.appendChild(opt);
}); selectEl.innerHTML = '';
el.value = sel||"";
if(el.value!==old) el.dispatchEvent(new Event('change')); const placeholder = document.createElement('option');
placeholder.value = '';
placeholder.textContent = placeholderText;
placeholder.disabled = true;
placeholder.selected = true;
selectEl.appendChild(placeholder);
items.forEach((item) => {
const option = mapper(item);
if (!option || typeof option.value === 'undefined') {
return;
} }
// initial population const opt = document.createElement('option');
populate(elems.supplier, Object.keys(data), node.supplier); opt.value = option.value;
opt.textContent = option.label;
selectEl.appendChild(opt);
});
if (selectedValue) {
selectEl.value = selectedValue;
if (!selectEl.value) {
selectEl.value = '';
}
} else {
selectEl.value = '';
}
if (selectEl.value !== previous) {
selectEl.dispatchEvent(new Event('change'));
}
}
const resolveCategoryKey = () => {
if (node.softwareType && categories[node.softwareType]) {
return node.softwareType;
}
if (node.category && categories[node.category]) {
return node.category;
}
return defaultCategory;
}; };
`
const categoryKey = resolveCategoryKey();
node.category = categoryKey;
const activeCategory = categoryKey ? categories[categoryKey] : null;
const suppliers = activeCategory ? activeCategory.suppliers : [];
populate(
elems.supplier,
suppliers,
node.supplier,
(supplier) => ({ value: supplier.id || supplier.name, label: supplier.name }),
suppliers.length ? 'Select...' : 'No suppliers available'
);
const activeSupplier = suppliers.find(
(supplier) => (supplier.id || supplier.name) === node.supplier
);
const types = activeSupplier ? activeSupplier.types : [];
populate(
elems.type,
types,
node.assetType,
(type) => ({ value: type.id || type.name, label: type.name }),
activeSupplier ? 'Select...' : 'Awaiting Supplier Selection'
);
const activeType = types.find(
(type) => (type.id || type.name) === node.assetType
);
const models = activeType ? activeType.models : [];
populate(
elems.model,
models,
node.model,
(model) => ({ value: model.id || model.name, label: model.name }),
activeType ? 'Select...' : 'Awaiting Type Selection'
);
const activeModel = models.find(
(model) => (model.id || model.name) === node.model
);
populate(
elems.unit,
activeModel ? activeModel.units || [] : [],
node.unit,
(unit) => ({ value: unit, label: unit }),
activeModel ? 'Select...' : activeType ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
);
};
`;
} }
getEventInjectionCode(nodeName) { getEventInjectionCode(nodeName) {
return ` return `
// Asset Event wiring for ${nodeName} // Asset event wiring for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.wireEvents = function(node) { window.EVOLV.nodes.${nodeName}.assetMenu.wireEvents = function(node) {
const data = window.EVOLV.nodes.${nodeName}.menuData.asset; const menuAsset = window.EVOLV.nodes.${nodeName}.menuData.asset || {};
const categories = menuAsset.categories || {};
const defaultCategory = menuAsset.defaultCategory || Object.keys(categories)[0] || null;
const elems = { const elems = {
supplier: document.getElementById('node-input-supplier'), supplier: document.getElementById('node-input-supplier'),
category: document.getElementById('node-input-category'),
type: document.getElementById('node-input-assetType'), type: document.getElementById('node-input-assetType'),
model: document.getElementById('node-input-model'), model: document.getElementById('node-input-model'),
unit: document.getElementById('node-input-unit') unit: document.getElementById('node-input-unit')
}; };
function populate(el, opts, sel) {
const old = el.value; function populate(selectEl, items = [], selectedValue, mapFn, placeholderText = 'Select...') {
el.innerHTML = '<option value="">Select…</option>'; const previous = selectEl.value;
(opts||[]).forEach(o=>{ const mapper = typeof mapFn === 'function'
const opt = document.createElement('option'); ? mapFn
opt.value = o; opt.textContent = o; : (value) => ({ value, label: value });
el.appendChild(opt);
}); selectEl.innerHTML = '';
el.value = sel||"";
if(el.value!==old) el.dispatchEvent(new Event('change')); const placeholder = document.createElement('option');
placeholder.value = '';
placeholder.textContent = placeholderText;
placeholder.disabled = true;
placeholder.selected = true;
selectEl.appendChild(placeholder);
items.forEach((item) => {
const option = mapper(item);
if (!option || typeof option.value === 'undefined') {
return;
} }
elems.supplier.addEventListener('change', ()=>{ const opt = document.createElement('option');
populate(elems.category, opt.value = option.value;
elems.supplier.value? Object.keys(data[elems.supplier.value]||{}) : [], opt.textContent = option.label;
node.category); selectEl.appendChild(opt);
}); });
elems.category.addEventListener('change', ()=>{
const s=elems.supplier.value, c=elems.category.value; if (selectedValue) {
populate(elems.type, selectEl.value = selectedValue;
(s&&c)? Object.keys(data[s][c]||{}) : [], if (!selectEl.value) {
node.assetType); selectEl.value = '';
}); }
elems.type.addEventListener('change', ()=>{ } else {
const s=elems.supplier.value, c=elems.category.value, t=elems.type.value; selectEl.value = '';
const md = (s&&c&&t)? data[s][c][t]||[] : []; }
populate(elems.model, md.map(m=>m.name), node.model); if (selectEl.value !== previous) {
}); selectEl.dispatchEvent(new Event('change'));
elems.model.addEventListener('change', ()=>{ }
const s=elems.supplier.value, c=elems.category.value, t=elems.type.value, m=elems.model.value; }
const md = (s&&c&&t)? data[s][c][t]||[] : [];
const entry = md.find(x=>x.name===m); const resolveCategoryKey = () => {
populate(elems.unit, entry? entry.units : [], node.unit); if (node.softwareType && categories[node.softwareType]) {
}); return node.softwareType;
}; }
` if (node.category && categories[node.category]) {
return node.category;
}
return defaultCategory;
};
const getActiveCategory = () => {
const key = resolveCategoryKey();
return key ? categories[key] : null;
};
node.category = resolveCategoryKey();
elems.supplier.addEventListener('change', () => {
const category = getActiveCategory();
const supplier = category
? category.suppliers.find(
(item) => (item.id || item.name) === elems.supplier.value
)
: null;
const types = supplier ? supplier.types : [];
populate(
elems.type,
types,
node.assetType,
(type) => ({ value: type.id || type.name, label: type.name }),
supplier ? 'Select...' : 'Awaiting Supplier Selection'
);
populate(elems.model, [], '', undefined, 'Awaiting Type Selection');
populate(elems.unit, [], '', undefined, 'Awaiting Type Selection');
});
elems.type.addEventListener('change', () => {
const category = getActiveCategory();
const supplier = category
? category.suppliers.find(
(item) => (item.id || item.name) === elems.supplier.value
)
: null;
const type = supplier
? supplier.types.find(
(item) => (item.id || item.name) === elems.type.value
)
: null;
const models = type ? type.models : [];
populate(
elems.model,
models,
node.model,
(model) => ({ value: model.id || model.name, label: model.name }),
type ? 'Select...' : 'Awaiting Type Selection'
);
populate(
elems.unit,
[],
'',
undefined,
type ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
);
});
elems.model.addEventListener('change', () => {
const category = getActiveCategory();
const supplier = category
? category.suppliers.find(
(item) => (item.id || item.name) === elems.supplier.value
)
: null;
const type = supplier
? supplier.types.find(
(item) => (item.id || item.name) === elems.type.value
)
: null;
const model = type
? type.models.find(
(item) => (item.id || item.name) === elems.model.value
)
: null;
populate(
elems.unit,
model ? model.units || [] : [],
node.unit,
(unit) => ({ value: unit, label: unit }),
model ? 'Select...' : type ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
);
});
};
`;
} }
/**
* Generate HTML template for asset fields
*/
getHtmlTemplate() { getHtmlTemplate() {
return ` return `
<!-- Asset Properties --> <!-- Asset Properties -->
@@ -172,10 +366,6 @@ getEventInjectionCode(nodeName) {
<label for="node-input-supplier"><i class="fa fa-industry"></i> Supplier</label> <label for="node-input-supplier"><i class="fa fa-industry"></i> Supplier</label>
<select id="node-input-supplier" style="width:70%;"></select> <select id="node-input-supplier" style="width:70%;"></select>
</div> </div>
<div class="form-row">
<label for="node-input-category"><i class="fa fa-sitemap"></i> Category</label>
<select id="node-input-category" style="width:70%;"></select>
</div>
<div class="form-row"> <div class="form-row">
<label for="node-input-assetType"><i class="fa fa-puzzle-piece"></i> Type</label> <label for="node-input-assetType"><i class="fa fa-puzzle-piece"></i> Type</label>
<select id="node-input-assetType" style="width:70%;"></select> <select id="node-input-assetType" style="width:70%;"></select>
@@ -192,11 +382,10 @@ getEventInjectionCode(nodeName) {
`; `;
} }
/**
* Get client-side HTML injection code
*/
getHtmlInjectionCode(nodeName) { getHtmlInjectionCode(nodeName) {
const htmlTemplate = this.getHtmlTemplate().replace(/`/g, '\\`').replace(/\$/g, '\\$'); const htmlTemplate = this.getHtmlTemplate()
.replace(/`/g, '\\`')
.replace(/\$/g, '\\$');
return ` return `
// Asset HTML injection for ${nodeName} // Asset HTML injection for ${nodeName}
@@ -210,33 +399,53 @@ getEventInjectionCode(nodeName) {
`; `;
} }
/**
* Returns the JS that injects the saveEditor function
*/
getSaveInjectionCode(nodeName) { getSaveInjectionCode(nodeName) {
return ` return `
// Asset Save injection for ${nodeName} // Asset save handler for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.saveEditor = function(node) { window.EVOLV.nodes.${nodeName}.assetMenu.saveEditor = function(node) {
console.log('Saving asset properties for ${nodeName}…'); console.log('Saving asset properties for ${nodeName}');
const fields = ['supplier','category','assetType','model','unit']; const menuAsset = window.EVOLV.nodes.${nodeName}.menuData.asset || {};
const errors = []; const categories = menuAsset.categories || {};
fields.forEach(f => { const defaultCategory = menuAsset.defaultCategory || Object.keys(categories)[0] || null;
const el = document.getElementById(\`node-input-\${f}\`); const resolveCategoryKey = () => {
node[f] = el ? el.value : ''; if (node.softwareType && categories[node.softwareType]) {
}); return node.softwareType;
if (node.assetType && !node.unit) errors.push('Unit must be set when type is specified.'); }
if (!node.unit) errors.push('Unit is required.'); if (node.category && categories[node.category]) {
errors.forEach(e=>RED.notify(e,'error')); return node.category;
}
return defaultCategory || '';
};
// --- DEBUG: show exactly what was saved --- node.category = resolveCategoryKey();
const saved = fields.reduce((o,f) => { o[f] = node[f]; return o; }, {});
console.log('→ assetMenu.saveEditor result:', saved); const fields = ['supplier', 'assetType', 'model', 'unit'];
const errors = [];
fields.forEach((field) => {
const el = document.getElementById(\`node-input-\${field}\`);
node[field] = el ? el.value : '';
});
if (node.assetType && !node.unit) {
errors.push('Unit must be set when a type is specified.');
}
if (!node.unit) {
errors.push('Unit is required.');
}
errors.forEach((msg) => RED.notify(msg, 'error'));
const saved = fields.reduce((acc, field) => {
acc[field] = node[field];
return acc;
}, {});
console.log('[AssetMenu] save result:', saved);
return errors.length === 0; return errors.length === 0;
}; };
`; `;
} }
} }
module.exports = AssetMenu; module.exports = AssetMenu;

243
src/menu/asset_DEPRECATED.js Normal file
View File

@@ -0,0 +1,243 @@
// asset.js
const fs = require('fs');
const path = require('path');
class AssetMenu {
/** Define path where to find data of assets in constructor for now */
constructor(relPath = '../../datasets/assetData') {
this.baseDir = path.resolve(__dirname, relPath);
this.assetData = this._loadJSON('assetData');
}
_loadJSON(...segments) {
const filePath = path.resolve(this.baseDir, ...segments) + '.json';
try {
return JSON.parse(fs.readFileSync(filePath, 'utf8'));
} catch (err) {
throw new Error(`Failed to load ${filePath}: ${err.message}`);
}
}
/**
* ADD THIS METHOD
* Compiles all menu data from the file system into a single nested object.
* This is run once on the server to pre-load everything.
* @returns {object} A comprehensive object with all menu options.
*/
getAllMenuData() {
// load the raw JSON once
const data = this._loadJSON('assetData');
const allData = {};
data.suppliers.forEach(sup => {
allData[sup.name] = {};
sup.categories.forEach(cat => {
allData[sup.name][cat.name] = {};
cat.types.forEach(type => {
// here: store the full array of model objects, not just names
allData[sup.name][cat.name][type.name] = type.models;
});
});
});
return allData;
}
/**
* Convert the static initEditor function to a string that can be served to the client
* @param {string} nodeName - The name of the node type
* @returns {string} JavaScript code as a string
*/
getClientInitCode(nodeName) {
// step 1: get the two helper strings
const htmlCode = this.getHtmlInjectionCode(nodeName);
const dataCode = this.getDataInjectionCode(nodeName);
const eventsCode = this.getEventInjectionCode(nodeName);
const saveCode = this.getSaveInjectionCode(nodeName);
return `
// --- AssetMenu for ${nodeName} ---
window.EVOLV.nodes.${nodeName}.assetMenu =
window.EVOLV.nodes.${nodeName}.assetMenu || {};
${htmlCode}
${dataCode}
${eventsCode}
${saveCode}
// wire it all up when the editor loads
window.EVOLV.nodes.${nodeName}.assetMenu.initEditor = function(node) {
// ------------------ BELOW sequence is important! -------------------------------
console.log('Initializing asset properties for ${nodeName}…');
this.injectHtml();
// load the data and wire up events
// this will populate the fields and set up the event listeners
this.wireEvents(node);
// this will load the initial data into the fields
// this is important to ensure the fields are populated correctly
this.loadData(node);
};
`;
}
getDataInjectionCode(nodeName) {
return `
// Asset Data loader for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.loadData = function(node) {
const data = window.EVOLV.nodes.${nodeName}.menuData.asset;
const elems = {
supplier: document.getElementById('node-input-supplier'),
category: document.getElementById('node-input-category'),
type: document.getElementById('node-input-assetType'),
model: document.getElementById('node-input-model'),
unit: document.getElementById('node-input-unit')
};
function populate(el, opts, sel) {
const old = el.value;
el.innerHTML = '<option value="">Select…</option>';
(opts||[]).forEach(o=>{
const opt = document.createElement('option');
opt.value = o; opt.textContent = o;
el.appendChild(opt);
});
el.value = sel||"";
if(el.value!==old) el.dispatchEvent(new Event('change'));
}
// initial population
populate(elems.supplier, Object.keys(data), node.supplier);
};
`
}
getEventInjectionCode(nodeName) {
return `
// Asset Event wiring for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.wireEvents = function(node) {
const data = window.EVOLV.nodes.${nodeName}.menuData.asset;
const elems = {
supplier: document.getElementById('node-input-supplier'),
category: document.getElementById('node-input-category'),
type: document.getElementById('node-input-assetType'),
model: document.getElementById('node-input-model'),
unit: document.getElementById('node-input-unit')
};
function populate(el, opts, sel) {
const old = el.value;
el.innerHTML = '<option value="">Select…</option>';
(opts||[]).forEach(o=>{
const opt = document.createElement('option');
opt.value = o; opt.textContent = o;
el.appendChild(opt);
});
el.value = sel||"";
if(el.value!==old) el.dispatchEvent(new Event('change'));
}
elems.supplier.addEventListener('change', ()=>{
populate(elems.category,
elems.supplier.value? Object.keys(data[elems.supplier.value]||{}) : [],
node.category);
});
elems.category.addEventListener('change', ()=>{
const s=elems.supplier.value, c=elems.category.value;
populate(elems.type,
(s&&c)? Object.keys(data[s][c]||{}) : [],
node.assetType);
});
elems.type.addEventListener('change', ()=>{
const s=elems.supplier.value, c=elems.category.value, t=elems.type.value;
const md = (s&&c&&t)? data[s][c][t]||[] : [];
populate(elems.model, md.map(m=>m.name), node.model);
});
elems.model.addEventListener('change', ()=>{
const s=elems.supplier.value, c=elems.category.value, t=elems.type.value, m=elems.model.value;
const md = (s&&c&&t)? data[s][c][t]||[] : [];
const entry = md.find(x=>x.name===m);
populate(elems.unit, entry? entry.units : [], node.unit);
});
};
`
}
/**
* Generate HTML template for asset fields
*/
getHtmlTemplate() {
return `
<!-- Asset Properties -->
<hr />
<h3>Asset selection</h3>
<div class="form-row">
<label for="node-input-supplier"><i class="fa fa-industry"></i> Supplier</label>
<select id="node-input-supplier" style="width:70%;"></select>
</div>
<div class="form-row">
<label for="node-input-category"><i class="fa fa-sitemap"></i> Category</label>
<select id="node-input-category" style="width:70%;"></select>
</div>
<div class="form-row">
<label for="node-input-assetType"><i class="fa fa-puzzle-piece"></i> Type</label>
<select id="node-input-assetType" style="width:70%;"></select>
</div>
<div class="form-row">
<label for="node-input-model"><i class="fa fa-wrench"></i> Model</label>
<select id="node-input-model" style="width:70%;"></select>
</div>
<div class="form-row">
<label for="node-input-unit"><i class="fa fa-balance-scale"></i> Unit</label>
<select id="node-input-unit" style="width:70%;"></select>
</div>
<hr />
`;
}
/**
* Get client-side HTML injection code
*/
getHtmlInjectionCode(nodeName) {
const htmlTemplate = this.getHtmlTemplate().replace(/`/g, '\\`').replace(/\$/g, '\\$');
return `
// Asset HTML injection for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.injectHtml = function() {
const placeholder = document.getElementById('asset-fields-placeholder');
if (placeholder && !placeholder.hasChildNodes()) {
placeholder.innerHTML = \`${htmlTemplate}\`;
console.log('Asset HTML injected successfully');
}
};
`;
}
/**
* Returns the JS that injects the saveEditor function
*/
getSaveInjectionCode(nodeName) {
return `
// Asset Save injection for ${nodeName}
window.EVOLV.nodes.${nodeName}.assetMenu.saveEditor = function(node) {
console.log('Saving asset properties for ${nodeName}…');
const fields = ['supplier','category','assetType','model','unit'];
const errors = [];
fields.forEach(f => {
const el = document.getElementById(\`node-input-\${f}\`);
node[f] = el ? el.value : '';
});
if (node.assetType && !node.unit) errors.push('Unit must be set when type is specified.');
if (!node.unit) errors.push('Unit is required.');
errors.forEach(e=>RED.notify(e,'error'));
// --- DEBUG: show exactly what was saved ---
const saved = fields.reduce((o,f) => { o[f] = node[f]; return o; }, {});
console.log('→ assetMenu.saveEditor result:', saved);
return errors.length===0;
};
`;
}
}
module.exports = AssetMenu;

22
src/menu/index.js
View File

@@ -2,13 +2,17 @@ const AssetMenu = require('./asset.js');
const { TagcodeApp, DynamicAssetMenu } = require('./tagcodeApp.js'); const { TagcodeApp, DynamicAssetMenu } = require('./tagcodeApp.js');
const LoggerMenu = require('./logger.js'); const LoggerMenu = require('./logger.js');
const PhysicalPositionMenu = require('./physicalPosition.js'); const PhysicalPositionMenu = require('./physicalPosition.js');
const ConfigManager = require('../configs');
class MenuManager { class MenuManager {
constructor() { constructor() {
this.registeredMenus = new Map(); this.registeredMenus = new Map();
this.configManager = new ConfigManager('../configs');
// Register factory functions // Register factory functions
this.registerMenu('asset', () => new AssetMenu()); // static menu to be replaced by dynamic one but later this.registerMenu('asset', (nodeName) => new AssetMenu({
softwareType: this._getSoftwareType(nodeName)
})); // static menu to be replaced by dynamic one but later
//this.registerMenu('asset', (nodeName) => new DynamicAssetMenu(nodeName, new TagcodeApp())); //this.registerMenu('asset', (nodeName) => new DynamicAssetMenu(nodeName, new TagcodeApp()));
this.registerMenu('logger', () => new LoggerMenu()); this.registerMenu('logger', () => new LoggerMenu());
this.registerMenu('position', () => new PhysicalPositionMenu()); this.registerMenu('position', () => new PhysicalPositionMenu());
@@ -23,6 +27,20 @@ class MenuManager {
this.registeredMenus.set(menuType, menuFactory); this.registeredMenus.set(menuType, menuFactory);
} }
_getSoftwareType(nodeName) {
if (!nodeName) {
return null;
}
try {
const config = this.configManager.getConfig(nodeName);
return config?.functionality?.softwareType || nodeName;
} catch (error) {
console.warn(`Unable to determine softwareType for ${nodeName}: ${error.message}`);
return nodeName;
}
}
/** /**
* Create a complete endpoint script with data and initialization functions * Create a complete endpoint script with data and initialization functions
* @param {string} nodeName - The name of the node type * @param {string} nodeName - The name of the node type
@@ -54,7 +72,7 @@ class MenuManager {
try { try {
const handler = instantiatedMenus.get(menuType); const handler = instantiatedMenus.get(menuType);
if (handler && typeof handler.getAllMenuData === 'function') { if (handler && typeof handler.getAllMenuData === 'function') {
menuData[menuType] = handler.getAllMenuData(); menuData[menuType] = handler.getAllMenuData(nodeName);
} else { } else {
// Provide default empty data if method doesn't exist // Provide default empty data if method doesn't exist
menuData[menuType] = {}; menuData[menuType] = {};

4
src/menu/physicalPosition.js
View File

@@ -6,9 +6,9 @@ class PhysicalPositionMenu {
return { return {
positionGroups: [ positionGroups: [
{ group: 'Positional', options: [ { group: 'Positional', options: [
{ value: 'upstream', label: '← Upstream', icon: '←'}, { value: 'upstream', label: '→ Upstream', icon: '→'}, //flow is then typically left to right
{ value: 'atEquipment', label: '⊥ in place' , icon: '⊥' }, { value: 'atEquipment', label: '⊥ in place' , icon: '⊥' },
{ value: 'downstream', label: '→ Downstream' , icon: '→' } { value: 'downstream', label: '← Downstream' , icon: '←' }
] ]
} }
], ],

279
src/pid/PIDController.js Normal file
View File

@@ -0,0 +1,279 @@
'use strict';
/**
* Discrete PID controller with optional derivative filtering and integral limits.
* Sample times are expressed in milliseconds to align with Node.js timestamps.
*/
class PIDController {
constructor(options = {}) {
const {
kp = 1,
ki = 0,
kd = 0,
sampleTime = 1000,
derivativeFilter = 0.15,
outputMin = Number.NEGATIVE_INFINITY,
outputMax = Number.POSITIVE_INFINITY,
integralMin = null,
integralMax = null,
derivativeOnMeasurement = true,
autoMode = true
} = options;
this.kp = 0;
this.ki = 0;
this.kd = 0;
this.setTunings({ kp, ki, kd });
this.setSampleTime(sampleTime);
this.setOutputLimits(outputMin, outputMax);
this.setIntegralLimits(integralMin, integralMax);
this.setDerivativeFilter(derivativeFilter);
this.derivativeOnMeasurement = Boolean(derivativeOnMeasurement);
this.autoMode = Boolean(autoMode);
this.reset();
}
/**
* Update controller gains at runtime.
* Accepts partial objects, e.g. setTunings({ kp: 2.0 }).
*/
setTunings({ kp = this.kp, ki = this.ki, kd = this.kd } = {}) {
[kp, ki, kd].forEach((gain, index) => {
if (!Number.isFinite(gain)) {
const label = ['kp', 'ki', 'kd'][index];
throw new TypeError(`${label} must be a finite number`);
}
});
this.kp = kp;
this.ki = ki;
this.kd = kd;
return this;
}
/**
* Set the controller execution interval in milliseconds.
*/
setSampleTime(sampleTimeMs = this.sampleTime) {
if (!Number.isFinite(sampleTimeMs) || sampleTimeMs <= 0) {
throw new RangeError('sampleTime must be a positive number of milliseconds');
}
this.sampleTime = sampleTimeMs;
return this;
}
/**
* Constrain controller output.
*/
setOutputLimits(min = this.outputMin, max = this.outputMax) {
if (!Number.isFinite(min) && min !== Number.NEGATIVE_INFINITY) {
throw new TypeError('outputMin must be finite or -Infinity');
}
if (!Number.isFinite(max) && max !== Number.POSITIVE_INFINITY) {
throw new TypeError('outputMax must be finite or Infinity');
}
if (min >= max) {
throw new RangeError('outputMin must be smaller than outputMax');
}
this.outputMin = min;
this.outputMax = max;
this.lastOutput = this._clamp(this.lastOutput ?? 0, this.outputMin, this.outputMax);
return this;
}
/**
* Constrain the accumulated integral term.
*/
setIntegralLimits(min = this.integralMin ?? null, max = this.integralMax ?? null) {
if (min !== null && !Number.isFinite(min)) {
throw new TypeError('integralMin must be null or a finite number');
}
if (max !== null && !Number.isFinite(max)) {
throw new TypeError('integralMax must be null or a finite number');
}
if (min !== null && max !== null && min > max) {
throw new RangeError('integralMin must be smaller than integralMax');
}
this.integralMin = min;
this.integralMax = max;
this.integral = this._applyIntegralLimits(this.integral ?? 0);
return this;
}
/**
* Configure exponential filter applied to the derivative term.
* Value 0 disables filtering, 1 keeps the previous derivative entirely.
*/
setDerivativeFilter(value = this.derivativeFilter ?? 0) {
if (!Number.isFinite(value) || value < 0 || value > 1) {
throw new RangeError('derivativeFilter must be between 0 and 1');
}
this.derivativeFilter = value;
return this;
}
/**
* Switch between automatic (closed-loop) and manual mode.
*/
setMode(mode) {
if (mode !== 'automatic' && mode !== 'manual') {
throw new Error('mode must be either "automatic" or "manual"');
}
this.autoMode = mode === 'automatic';
return this;
}
/**
* Force a manual output (typically when in manual mode).
*/
setManualOutput(value) {
this._assertNumeric('manual output', value);
this.lastOutput = this._clamp(value, this.outputMin, this.outputMax);
return this.lastOutput;
}
/**
* Reset dynamic state (integral, derivative memory, timestamps).
*/
reset(state = {}) {
const {
integral = 0,
lastOutput = 0,
timestamp = null
} = state;
this.integral = this._applyIntegralLimits(Number.isFinite(integral) ? integral : 0);
this.prevError = null;
this.prevMeasurement = null;
this.lastOutput = this._clamp(
Number.isFinite(lastOutput) ? lastOutput : 0,
this.outputMin ?? Number.NEGATIVE_INFINITY,
this.outputMax ?? Number.POSITIVE_INFINITY
);
this.lastTimestamp = Number.isFinite(timestamp) ? timestamp : null;
this.derivativeState = 0;
return this;
}
/**
* Execute one control loop iteration.
*/
update(setpoint, measurement, timestamp = Date.now()) {
this._assertNumeric('setpoint', setpoint);
this._assertNumeric('measurement', measurement);
this._assertNumeric('timestamp', timestamp);
if (!this.autoMode) {
this.prevError = setpoint - measurement;
this.prevMeasurement = measurement;
this.lastTimestamp = timestamp;
return this.lastOutput;
}
if (this.lastTimestamp !== null && (timestamp - this.lastTimestamp) < this.sampleTime) {
return this.lastOutput;
}
const elapsedMs = this.lastTimestamp === null ? this.sampleTime : (timestamp - this.lastTimestamp);
const dtSeconds = Math.max(elapsedMs / 1000, Number.EPSILON);
const error = setpoint - measurement;
this.integral = this._applyIntegralLimits(this.integral + error * dtSeconds);
const derivative = this._computeDerivative({ error, measurement, dtSeconds });
this.derivativeState = this.derivativeFilter === 0
? derivative
: this.derivativeState + (derivative - this.derivativeState) * (1 - this.derivativeFilter);
const output = (this.kp * error) + (this.ki * this.integral) + (this.kd * this.derivativeState);
this.lastOutput = this._clamp(output, this.outputMin, this.outputMax);
this.prevError = error;
this.prevMeasurement = measurement;
this.lastTimestamp = timestamp;
return this.lastOutput;
}
/**
* Inspect controller state for diagnostics or persistence.
*/
getState() {
return {
kp: this.kp,
ki: this.ki,
kd: this.kd,
sampleTime: this.sampleTime,
outputLimits: { min: this.outputMin, max: this.outputMax },
integralLimits: { min: this.integralMin, max: this.integralMax },
derivativeFilter: this.derivativeFilter,
derivativeOnMeasurement: this.derivativeOnMeasurement,
autoMode: this.autoMode,
integral: this.integral,
lastOutput: this.lastOutput,
lastTimestamp: this.lastTimestamp
};
}
getLastOutput() {
return this.lastOutput;
}
_computeDerivative({ error, measurement, dtSeconds }) {
if (!(dtSeconds > 0) || !Number.isFinite(dtSeconds)) {
return 0;
}
if (this.derivativeOnMeasurement && this.prevMeasurement !== null) {
return -(measurement - this.prevMeasurement) / dtSeconds;
}
if (this.prevError === null) {
return 0;
}
return (error - this.prevError) / dtSeconds;
}
_applyIntegralLimits(value) {
if (!Number.isFinite(value)) {
return 0;
}
let result = value;
if (this.integralMin !== null && result < this.integralMin) {
result = this.integralMin;
}
if (this.integralMax !== null && result > this.integralMax) {
result = this.integralMax;
}
return result;
}
_assertNumeric(label, value) {
if (!Number.isFinite(value)) {
throw new TypeError(`${label} must be a finite number`);
}
}
_clamp(value, min, max) {
if (value < min) {
return min;
}
if (value > max) {
return max;
}
return value;
}
}
module.exports = PIDController;

87
src/pid/examples.js Normal file
View File

@@ -0,0 +1,87 @@
const { PIDController } = require('./index');
console.log('=== PID CONTROLLER EXAMPLES ===\n');
console.log('This guide shows how to instantiate, tune, and operate the PID helper.\n');
// ====================================
// EXAMPLE 1: FLOW CONTROL LOOP
// ====================================
console.log('--- Example 1: Pump speed control ---');
const pumpController = new PIDController({
kp: 1.1,
ki: 0.35,
kd: 0.08,
sampleTime: 250, // ms
outputMin: 0,
outputMax: 100,
derivativeFilter: 0.2
});
const pumpSetpoint = 75; // desired flow percentage
let pumpFlow = 20;
const pumpStart = Date.now();
for (let i = 0; i < 10; i += 1) {
const timestamp = pumpStart + (i + 1) * pumpController.sampleTime;
const controlSignal = pumpController.update(pumpSetpoint, pumpFlow, timestamp);
// Simple first-order plant approximation
pumpFlow += (controlSignal - pumpFlow) * 0.12;
pumpFlow -= (pumpFlow - pumpSetpoint) * 0.05; // disturbance rejection
console.log(
`Cycle ${i + 1}: output=${controlSignal.toFixed(2)}% | flow=${pumpFlow.toFixed(2)}%`
);
}
console.log('Pump loop state:', pumpController.getState(), '\n');
// ====================================
// EXAMPLE 2: TANK LEVEL WITH MANUAL/AUTO
// ====================================
console.log('--- Example 2: Tank level handover ---');
const tankController = new PIDController({
kp: 2.0,
ki: 0.5,
kd: 0.25,
sampleTime: 400,
derivativeFilter: 0.25,
outputMin: 0,
outputMax: 1
}).setIntegralLimits(-0.3, 0.3);
tankController.setMode('manual');
tankController.setManualOutput(0.4);
console.log(`Manual output locked at ${tankController.getLastOutput().toFixed(2)}\n`);
tankController.setMode('automatic');
let level = 0.2;
const levelSetpoint = 0.8;
const tankStart = Date.now();
for (let step = 0; step < 8; step += 1) {
const timestamp = tankStart + (step + 1) * tankController.sampleTime;
const output = tankController.update(levelSetpoint, level, timestamp);
// Integrating process with slight disturbance
level += (output - 0.5) * 0.18;
level += 0.02; // inflow bump
level = Math.max(0, Math.min(1, level));
console.log(
`Cycle ${step + 1}: output=${output.toFixed(3)} | level=${level.toFixed(3)}`
);
}
console.log('\nBest practice tips:');
console.log(' - Call update() on a fixed interval (sampleTime).');
console.log(' - Clamp output and integral to avoid windup.');
console.log(' - Use setMode("manual") during maintenance or bump-less transfer.');
module.exports = {
pumpController,
tankController
};

11
src/pid/index.js Normal file
View File

@@ -0,0 +1,11 @@
const PIDController = require('./PIDController');
/**
* Convenience factory for one-line instantiation.
*/
const createPidController = (options) => new PIDController(options);
module.exports = {
PIDController,
createPidController
};

4
src/state/state.js
View File

@@ -52,6 +52,10 @@ class state{
return this.stateManager.getRunTimeHours(); return this.stateManager.getRunTimeHours();
} }
getMaintenanceTimeHours(){
return this.stateManager.getMaintenanceTimeHours();
}
async moveTo(targetPosition) { async moveTo(targetPosition) {

18
src/state/stateConfig.json
View File

@@ -205,6 +205,10 @@
{ {
"value": "off", "value": "off",
"description": "Machine is off." "description": "Machine is off."
},
{
"value": "maintenance",
"description": "Machine locked for inspection or repair; automatic control disabled."
} }
], ],
"description": "Current state of the machine." "description": "Current state of the machine."
@@ -216,7 +220,7 @@
"type": "object", "type": "object",
"schema": { "schema": {
"idle": { "idle": {
"default": ["starting", "off","emergencystop"], "default": ["starting", "off","emergencystop","maintenance"],
"rules":{ "rules":{
"type": "set", "type": "set",
"itemType": "string", "itemType": "string",
@@ -280,7 +284,7 @@
} }
}, },
"off": { "off": {
"default": ["idle","emergencystop"], "default": ["idle","emergencystop","maintenance"],
"rules":{ "rules":{
"type": "set", "type": "set",
"itemType": "string", "itemType": "string",
@@ -288,12 +292,20 @@
} }
}, },
"emergencystop": { "emergencystop": {
"default": ["idle","off"], "default": ["idle","off","maintenance"],
"rules":{ "rules":{
"type": "set", "type": "set",
"itemType": "string", "itemType": "string",
"description": "Allowed transitions from emergency stop state." "description": "Allowed transitions from emergency stop state."
} }
},
"maintenance": {
"default": ["maintenance","idle","off"],
"rules":{
"type": "set",
"itemType": "string",
"description": "Allowed transitions for maintenance mode"
}
} }
}, },
"description": "Allowed transitions between states." "description": "Allowed transitions between states."

43
src/state/stateManager.js
View File

@@ -48,10 +48,14 @@ class stateManager {
// Define valid transitions (can be extended dynamically if needed) // Define valid transitions (can be extended dynamically if needed)
this.validTransitions = config.state.allowedTransitions; this.validTransitions = config.state.allowedTransitions;
// NEW: Initialize runtime tracking //runtime tracking
this.runTimeHours = 0; // cumulative runtime in hours this.runTimeHours = 0; // cumulative runtime in hours
this.runTimeStart = null; // timestamp when active state began this.runTimeStart = null; // timestamp when active state began
//maintenance tracking
this.maintenanceTimeStart = null; //timestamp when active state began
this.maintenanceTimeHours = 0; //cumulative
// Define active states (runtime counts only in these states) // Define active states (runtime counts only in these states)
this.activeStates = config.state.activeStates; this.activeStates = config.state.activeStates;
} }
@@ -73,8 +77,9 @@ class stateManager {
); //go back early and reject promise ); //go back early and reject promise
} }
// NEW: Handle runtime tracking based on active states //Time tracking based on active states
this.handleRuntimeTracking(newState); this.handleRuntimeTracking(newState);
this.handleMaintenancetimeTracking(newState);
const transitionDuration = this.transitionTimes[this.currentState] || 0; // Default to 0 if no transition time const transitionDuration = this.transitionTimes[this.currentState] || 0; // Default to 0 if no transition time
this.logger.debug( this.logger.debug(
@@ -100,7 +105,7 @@ class stateManager {
} }
handleRuntimeTracking(newState) { handleRuntimeTracking(newState) {
// NEW: Handle runtime tracking based on active states //Handle runtime tracking based on active states
const wasActive = this.activeStates.has(this.currentState); const wasActive = this.activeStates.has(this.currentState);
const willBeActive = this.activeStates.has(newState); const willBeActive = this.activeStates.has(newState);
if (wasActive && !willBeActive && this.runTimeStart) { if (wasActive && !willBeActive && this.runTimeStart) {
@@ -120,6 +125,28 @@ class stateManager {
} }
} }
handleMaintenancetimeTracking(newState) {
//is this maintenance time ?
const wasActive = (this.currentState == "maintenance"? true:false);
const willBeActive = ( newState == "maintenance" ? true:false );
if (wasActive && this.maintenanceTimeStart) {
// stop runtime timer and accumulate elapsed time
const elapsed = (Date.now() - this.maintenanceTimeStart) / 3600000; // hours
this.maintenanceTimeHours += elapsed;
this.maintenanceTimeStart = null;
this.logger.debug(
`Maintenance timer stopped; elapsed=${elapsed.toFixed(
3
)}h, total=${this.maintenanceTimeHours.toFixed(3)}h.`
);
} else if (willBeActive && !this.runTimeStart) {
// starting new runtime
this.maintenanceTimeStart = Date.now();
this.logger.debug("Runtime timer started.");
}
}
isValidTransition(newState) { isValidTransition(newState) {
this.logger.debug( this.logger.debug(
`Check 1 Transition valid ? From ${ `Check 1 Transition valid ? From ${
@@ -150,7 +177,6 @@ class stateManager {
return this.descriptions[state] || "No description available."; return this.descriptions[state] || "No description available.";
} }
// NEW: Getter to retrieve current cumulative runtime (active time) in hours.
getRunTimeHours() { getRunTimeHours() {
// If currently active add the ongoing duration. // If currently active add the ongoing duration.
let currentElapsed = 0; let currentElapsed = 0;
@@ -159,6 +185,15 @@ class stateManager {
} }
return this.runTimeHours + currentElapsed; return this.runTimeHours + currentElapsed;
} }
getMaintenanceTimeHours() {
// If currently active add the ongoing duration.
let currentElapsed = 0;
if (this.maintenanceTimeStart) {
currentElapsed = (Date.now() - this.maintenanceTimeStart) / 3600000;
}
return this.maintenanceTimeHours + currentElapsed;
}
} }
module.exports = stateManager; module.exports = stateManager;