woutverheijen/rotatingMachine
1
0
Fork 0
forked from RnD/rotatingMachine
Code Pull Requests Activity

updated child registration and measurement process

Browse Source
This commit is contained in:
znetsixe
2025-08-08 14:29:15 +02:00
parent 7820bd2ad2
commit 82bb55e10f
1 changed files with 131 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
src/specificClass.js
View File

@@ -116,66 +116,138 @@ class Machine {
}
/*------------------- Register child events -------------------*/
registerOnChildEvents() {
this.logger.debug('Setting up child event listeners');
registerOnChildEvents() {
this.logger.debug('Setting up child event listeners');
// ✅ Use utility to get sensors (but keep your manual control)
const sensors = this.childRegistrationUtils.getChildrenOfType('measurement', 'sensor');
if (sensors.length === 0) {
this.logger.warn('No measurement sensors found to register events for');
return;
}
const sensors = this.childRegistrationUtils.getChildrenOfType('measurement', 'sensor');
if (sensors.length === 0) {
this.logger.warn('No measurement sensors found to register events for');
return;
}
this.logger.debug(`Found ${sensors.length} sensors to register events for`);
// ✅ Register events for each sensor
sensors.forEach(sensor => {
switch (sensor.config.asset.type) {
case 'pressure':
this.logger.debug(`Registering pressure events for sensor: ${sensor.config.general.name}`);
// upstream pressure handling
sensor.measurements.emitter.on('pressure.measured.upstream', (eventData) => {
this.logger.debug(`🔄 Upstream pressure from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
// Update the measured pressure
this.updateMeasuredPressure(eventData.value, 'upstream', eventData);
});
// downstream pressure handling
sensor.measurements.emitter.on('pressure.measured.downstream', (eventData) => {
this.logger.debug(`🔄 Downstream pressure from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
// Update the measured pressure
this.updateMeasuredPressure(eventData.value, 'downstream', eventData);
});
break;
case 'flow':
this.logger.debug(`Registering flow events for sensor: ${sensor.config.general.name}`);
// upstream flow handling
sensors.forEach(sensor => {
sensor.measurements.emitter.on('flow.measured.upstream', (eventData) => {
this.logger.debug(`🔄 Upstream flow from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
this.updateMeasuredFlow(eventData.value, 'upstream', eventData);
});
// downstream flow handling
sensor.measurements.emitter.on('flow.measured.downstream', (eventData) => {
this.logger.debug(`🔄 Downstream flow from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
this.updateMeasuredFlow(eventData.value, 'downstream', eventData);
});
});
break;
default:
this.logger.warn(`Unknown sensor type: ${sensor.config.asset.type}. No events registered.`);
break;
}
});
// ✅ Log registration summary
this.logger.info(`✅ Event listeners registered for ${sensors.length} measurement sensors`);
// ✅ Optional: Debug child structure
this.childRegistrationUtils.logChildStructure();
this.logger.debug(`Found ${sensors.length} sensors to register events for`);
// Group sensors by type and position to detect duplicates
const sensorGroups = new Map(); // Key: "type_position", Value: array of sensors
sensors.forEach(sensor => {
const position = sensor.config.functionality.positionVsParent;
const measurementType = sensor.config.asset.type;
const key = `${measurementType}_${position}`;
if (!sensorGroups.has(key)) {
sensorGroups.set(key, []);
}
sensorGroups.get(key).push(sensor);
});
// Set up event handlers based on whether we have single or multiple sensors
sensorGroups.forEach((sensorsArray, key) => {
const [measurementType, position] = key.split('_');
if (sensorsArray.length === 1) {
// ✅ Single sensor - direct handler
const sensor = sensorsArray[0];
this._registerSingleSensorEvents(sensor, measurementType, position);
} else {
// ✅ Multiple sensors - averaging handler with warning
const sensorNames = sensorsArray.map(s => s.config.general.name).join(', ');
this.logger.warn(`⚠️ Multiple ${measurementType} sensors at ${position} position: ${sensorNames}. Using automatic averaging.`);
this._registerMultipleSensorEvents(sensorsArray, measurementType, position);
}
});
this.logger.info(`✅ Event listeners registered for ${sensors.length} measurement sensors`);
this.childRegistrationUtils.logChildStructure();
}
// Handle single sensor (no averaging needed)
_registerSingleSensorEvents(sensor, measurementType, position) {
const sensorName = sensor.config.general.name;
const eventName = `${measurementType}.measured.${position}`;
this.logger.debug(`Registering single ${measurementType} sensor: ${sensorName} at ${position}`);
sensor.measurements.emitter.on(eventName, (eventData) => {
this.logger.debug(`🔄 ${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
// Store directly in parent's measurement container
this.measurements
.type(measurementType)
.variant("measured")
.position(position)
.value(eventData.value, eventData.timestamp, eventData.unit);
// Call the appropriate handler
this._callMeasurementHandler(measurementType, eventData.value, position, eventData);
});
this.logger.debug(`✅ Registered single sensor event: ${eventName}`);
}
// Handle multiple sensors (with automatic averaging)
_registerMultipleSensorEvents(sensorsArray, measurementType, position) {
const eventName = `${measurementType}.measured.${position}`;
const sensorCount = sensorsArray.length;
this.logger.debug(`Registering ${sensorCount} ${measurementType} sensors at ${position} with averaging`);
// Register event handler for each sensor in the group
sensorsArray.forEach(sensor => {
sensor.measurements.emitter.on(eventName, (eventData) => {
this.logger.debug(`🔄 ${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit} (will be averaged)`);
// Store individual sensor value in parent's measurement container
this.measurements
.type(measurementType)
.variant("measured")
.position(position)
.value(eventData.value, eventData.timestamp, eventData.unit);
// Get the average from measurement container
const averageValue = this.measurements
.type(measurementType)
.variant("measured")
.position(position)
.getAverage();
this.logger.debug(`📊 Average ${position} ${measurementType} from ${sensorCount} sensors: ${averageValue}`);
// Call the handler with the averaged value
this._callMeasurementHandler(measurementType, averageValue, position, eventData);
});
});
this.logger.debug(`✅ Registered ${sensorCount} sensor events with averaging: ${eventName}`);
}
// Centralized handler dispatcher
_callMeasurementHandler(measurementType, value, position, context) {
switch (measurementType) {
case 'pressure':
this.updateMeasuredPressure(value, position, context);
break;
case 'flow':
this.updateMeasuredFlow(value, position, context);
break;
case 'temperature':
this.updateMeasuredTemperature(value, position, context);
break;
default:
this.logger.warn(`No handler for measurement type: ${measurementType}`);
// Generic handler - just update position
this.updatePosition();
break;
}
}
//---------------- END child stuff -------------//
// Method to assess drift using errorMetrics
assessDrift(measurement, processMin, processMax) {
@@ -522,8 +594,8 @@ class Machine {
// Store in parent's measurement container (your existing logic)
this.measurements.type("pressure").variant("measured").position(position).value(value, context.timestamp, context.unit);
// Your existing logic
// Determine what kind of value to use as pressure (upstream , downstream or difference)
const pressure = this.getMeasuredPressure();
this.updatePosition();