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

updated registration of measurements

Browse Source
This commit is contained in:
znetsixe
2025-09-04 17:07:29 +02:00
parent 82bb55e10f
commit f4696618a6
1 changed files with 23 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
src/specificClass.js
View File

@@ -92,7 +92,6 @@ class Machine {
this.measurements = new MeasurementContainer();
this.interpolation = new interpolation();
this.flowDrift = null;
this.currentMode = this.config.mode.current;
@@ -116,114 +115,32 @@ class Machine {
}
/*------------------- Register child events -------------------*/
registerOnChildEvents() {
this.logger.debug('Setting up child event listeners');
registerChild(child, softwareType) {
this.logger.debug('Setting up child event listeners');
const sensors = this.childRegistrationUtils.getChildrenOfType('measurement', 'sensor');
if (sensors.length === 0) {
this.logger.warn('No measurement sensors found to register events for');
return;
if(softwareType === "measurement"){
const position = child.config.functionality.positionVsParent;
const measurementType = child.config.asset.type;
const key = `${measurementType}_${position}`;
const eventName = `${measurementType}.measured.${position}`;
// Register event listener for measurement updates
child.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(`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) {