de9a79b888
Runtime (specificClass.js):
- Replace the "shift left both ramp ends" geometry with a true
hold-then-ramp hysteresis driven by output %, not level:
• Up-curve % crosses shiftArmPercent on the way up → ARM.
• Filling→draining transition while armed → capture the up-curve %
at that moment as _shiftHoldValue.
• Draining + level ≥ shiftLevel → output stays at _shiftHoldValue
(horizontal hold, matching the dashed segment in the SVG).
• Draining + level in [start, shift] → output ramps holdValue → 0 %
along the same curve shape (linear or log) as the up curve.
• Draining + level < startLevel → 0 % AND disarm.
• Returning to filling clears holdValue, stays armed; next drain
transition captures a fresh hold so bouncing fills rearm cleanly.
• Disarm only when level ≤ startLevel.
- New _curveShape(x) helper for shared linear/log shaping.
- Removed legacy _levelBasedRampStart / _levelBasedRampTop /
_updateShiftArmed in favour of the inline state machine.
Adapter (nodeClass.js):
- Pipe shiftArmPercent through to control.levelbased.
Editor (pumpingStation.html + src/editor/):
- Add shiftArmPercent input row (% with unit) to the mode side panel
(only shown when shifted ramp is enabled). Default 95 %.
- Add the horizontal arming-% line + label inside the mode SVG —
this is the "% Threshold triggering shifted ramp down" line from
the original drawing that had been missing.
- Redraw the shifted-down curve to match the SVG geometry literally:
100 % flat from maxLevel → shiftLevel, then ramp shiftLevel →
startLevel down to 0 %, OFF below startLevel. Preview shows the
worst-case envelope (hold = 100 %); runtime hold is captured live.
- Validation extended: 0 < shiftArmPercent ≤ 100; ordering rules
preserved (start < shift ≤ max etc.).
- Auto-default shiftArmPercent to 95 when shift is enabled and the
current value is missing or out of range.
Dashboard example (examples/basic-dashboard.flow.json):
- Parser now reads `level.predicted.atequipment.default` etc. The
MeasurementContainer flatten format includes the implicit 'default'
childId; consumers must include it. Comment in the parser points
at the documenting source in generalFunctions.
Tests:
- test/basic: replace old level-armed-shift tests with two new ones
that exercise the hold-then-ramp arming, capture, hold, ramp-down,
disarm, and the bounce case (filling→draining→filling→draining
captures a fresh hold each time).
- test/integration/shifted-ramp-end-to-end.test.js: new file. Drives
Q_IN/Q_OUT through the full runtime tick with a controllable clock,
asserting the same hysteresis path the dashboard exercises.
- test/integration/basic-dashboard-flow.test.js: fixture keys updated
to the .default-suffixed form so they match the real flatten output.
56/56 tests pass.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
95 lines
3.3 KiB
JavaScript
95 lines
3.3 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
|
|
function loadDashboardFlow() {
|
|
const flowPath = path.join(__dirname, '../../examples/basic-dashboard.flow.json');
|
|
return JSON.parse(fs.readFileSync(flowPath, 'utf8'));
|
|
}
|
|
|
|
function makeContextStub() {
|
|
const store = {};
|
|
return {
|
|
get(key) {
|
|
return store[key];
|
|
},
|
|
set(key, value) {
|
|
store[key] = value;
|
|
},
|
|
};
|
|
}
|
|
|
|
test('basic dashboard flow contains the pumpingStation node and trend widgets', () => {
|
|
const flow = loadDashboardFlow();
|
|
const ps = flow.find((n) => n.id === 'ps_node_basic');
|
|
const parser = flow.find((n) => n.id === 'ps_parse_output');
|
|
const levelChart = flow.find((n) => n.id === 'ps_chart_level');
|
|
const demandChart = flow.find((n) => n.id === 'ps_chart_demand');
|
|
|
|
assert.ok(ps, 'ps_node_basic should exist');
|
|
assert.equal(ps.type, 'pumpingStation');
|
|
assert.equal(ps.controlMode, 'levelbased');
|
|
assert.equal(ps.levelCurveType, 'linear');
|
|
assert.equal(ps.inletPipeDiameter, 0.4);
|
|
assert.equal(ps.outletPipeDiameter, 0.3);
|
|
assert.ok(parser, 'ps_parse_output should exist');
|
|
assert.equal(parser.outputs, 6);
|
|
assert.equal(levelChart.type, 'ui-chart');
|
|
assert.equal(demandChart.type, 'ui-chart');
|
|
});
|
|
|
|
test('basic dashboard parser routes process fields to charts and state text', () => {
|
|
const flow = loadDashboardFlow();
|
|
const parser = flow.find((n) => n.id === 'ps_parse_output');
|
|
assert.ok(parser, 'ps_parse_output should exist');
|
|
|
|
const func = new Function('msg', 'context', 'node', parser.func);
|
|
const context = makeContextStub();
|
|
const node = { send() {} };
|
|
|
|
// Flatten format is `${type}.${variant}.${position}.${childId}`. When the
|
|
// runtime writes without an explicit .child(), childId='default'. Mirror
|
|
// the real shape here. (See generalFunctions/src/measurements/
|
|
// MeasurementContainer.js getFlattenedOutput.)
|
|
const out = func({
|
|
payload: {
|
|
'level.predicted.atequipment.default': 3.25,
|
|
'volume.predicted.atequipment.default': 32.5,
|
|
'netFlowRate.predicted.atequipment.default': 0.003,
|
|
percControl: 25,
|
|
direction: 'filling',
|
|
safetyState: 'normal',
|
|
isOverflowing: false,
|
|
timeleft: 400,
|
|
},
|
|
}, context, node);
|
|
|
|
assert.ok(Array.isArray(out));
|
|
assert.equal(out.length, 6);
|
|
assert.equal(out[0].topic, 'level');
|
|
assert.equal(out[0].payload, 3.25);
|
|
assert.equal(out[1].topic, 'volume');
|
|
assert.equal(out[1].payload, 32.5);
|
|
assert.equal(out[2].topic, 'demand');
|
|
assert.equal(out[2].payload, 25);
|
|
assert.equal(out[3].topic, 'net_flow');
|
|
assert.equal(out[3].payload, 0.003);
|
|
assert.match(out[4].payload, /normal/);
|
|
assert.match(out[5].payload, /level=3.25 m/);
|
|
});
|
|
|
|
test('basic dashboard parser keeps previous values when process output sends only changed fields', () => {
|
|
const flow = loadDashboardFlow();
|
|
const parser = flow.find((n) => n.id === 'ps_parse_output');
|
|
const func = new Function('msg', 'context', 'node', parser.func);
|
|
const context = makeContextStub();
|
|
const node = { send() {} };
|
|
|
|
func({ payload: { 'level.predicted.atequipment.default': 3.1, percControl: 10 } }, context, node);
|
|
const out = func({ payload: { percControl: 20 } }, context, node);
|
|
|
|
assert.equal(out[0].payload, 3.1);
|
|
assert.equal(out[2].payload, 20);
|
|
});
|