From e416dab9dd39621cc0f4c325301b6d3b9abe031d Mon Sep 17 00:00:00 2001 From: Maurice Makaay Date: Mon, 20 Jul 2020 00:38:03 +0200 Subject: [PATCH] Temperature and humidity are now propagated to the distance sensor. --- src/App/App.cpp | 35 +++++++++++++++++------------ src/App/App.h | 8 ++++--- src/App/AppStateController.cpp | 4 ++-- src/App/AppStateController.h | 4 ++-- src/App/SensorControllerPlugin.h | 4 ++-- src/App/callbacks.cpp | 4 ++-- src/Sensors/SensorController.cpp | 38 +++++++++++++++----------------- src/Sensors/SensorController.h | 32 ++++++++++++++++++++++----- 8 files changed, 78 insertions(+), 51 deletions(-) diff --git a/src/App/App.cpp b/src/App/App.cpp index bc0fdd3..d63a91b 100644 --- a/src/App/App.cpp +++ b/src/App/App.cpp @@ -15,13 +15,14 @@ namespace Dough statePlugin(&ui, &mqtt), state(&statePlugin), sensorControllerPlugin(&mqtt, &ui), - distanceSensor( - new DistanceSensor(), &sensorControllerPlugin, + distanceSensor(), + distanceController( + &distanceSensor, &sensorControllerPlugin, DISTANCE_AVERAGE_STORAGE, DISTANCE_MEASURE_INTERVAL, MINIMUM_PUBLISH_INTERVAL), - temperatureSensor( + temperatureController( new TemperatureSensor(), &sensorControllerPlugin, TEMPERATURE_AVERAGE_STORAGE, TEMPERATURE_MEASURE_INTERVAL, MINIMUM_PUBLISH_INTERVAL), - humiditySensor( + humidityController( new HumiditySensor(), &sensorControllerPlugin, HUMIDITY_AVERAGE_STORAGE, HUMIDITY_MEASURE_INTERVAL, MINIMUM_PUBLISH_INTERVAL), _logger("APP") @@ -37,9 +38,9 @@ namespace Dough ui.setup(); wifi.setup(); mqtt.setup(); - temperatureSensor.setup(); - humiditySensor.setup(); - distanceSensor.setup(); + temperatureController.setup(); + humidityController.setup(); + distanceController.setup(); } void App::loop() @@ -71,9 +72,11 @@ namespace Dough case MEASURING: if (config.isOk()) { - temperatureSensor.loop(); - humiditySensor.loop(); - distanceSensor.loop(); + if (temperatureController.loop()) + distanceSensor.setTemperature(temperatureController.getLast().value); + if (humidityController.loop()) + distanceSensor.setHumidity(humidityController.getLast().value); + distanceController.loop(); } else { @@ -81,14 +84,18 @@ namespace Dough } break; case CALIBRATING: + temperatureController.loop(); + humidityController.loop(); + distanceController.loop(); + delay(2000); - state.pauseMeasurements(); + state.pauseDevice(); state.startMeasurements(); break; case PAUSED: - temperatureSensor.clearHistory(); - humiditySensor.clearHistory(); - distanceSensor.clearHistory(); + temperatureController.clearHistory(); + humidityController.clearHistory(); + distanceController.clearHistory(); break; default: // NOOP diff --git a/src/App/App.h b/src/App/App.h index 62bcd90..736c0b5 100644 --- a/src/App/App.h +++ b/src/App/App.h @@ -27,9 +27,11 @@ namespace Dough AppStateControllerPlugin statePlugin; AppStateController state; SensorControllerPlugin sensorControllerPlugin; - SensorController distanceSensor; - SensorController temperatureSensor; - SensorController humiditySensor; + DistanceSensor distanceSensor; + SensorController distanceController; + SensorController temperatureController; + SensorController humidityController; + void propagateMeasurement(const char* sensorName, int lastValue); void setup(); void loop(); diff --git a/src/App/AppStateController.cpp b/src/App/AppStateController.cpp index 6e85f4d..edff643 100644 --- a/src/App/AppStateController.cpp +++ b/src/App/AppStateController.cpp @@ -91,13 +91,13 @@ namespace Dough _updateState(); } - void AppStateController::pauseMeasurements() + void AppStateController::pauseDevice() { _paused = true; _updateState(); } - void AppStateController::resumeMeasurements() + void AppStateController::resumeDevice() { _paused = false; _updateState(); diff --git a/src/App/AppStateController.h b/src/App/AppStateController.h index 29dcb22..af681e9 100644 --- a/src/App/AppStateController.h +++ b/src/App/AppStateController.h @@ -53,8 +53,8 @@ namespace Dough void startConfiguration(); void startMeasurements(); void startCalibration(); - void pauseMeasurements(); - void resumeMeasurements(); + void pauseDevice(); + void resumeDevice(); AppState get(); private: diff --git a/src/App/SensorControllerPlugin.h b/src/App/SensorControllerPlugin.h index bde8a6b..a976fe8 100644 --- a/src/App/SensorControllerPlugin.h +++ b/src/App/SensorControllerPlugin.h @@ -1,5 +1,5 @@ -#ifndef DOUGH_SENSORCONTROLLER_PLUGINS_H -#define DOUGH_SENSORCONTROLLER_PLUGINS_H +#ifndef DOUGH_SENSORCONTROLLER_PLUGIN_H +#define DOUGH_SENSORCONTROLLER_PLUGIN_H #include #include "UI/Logger.h" diff --git a/src/App/callbacks.cpp b/src/App/callbacks.cpp index 811fdbc..d4934df 100644 --- a/src/App/callbacks.cpp +++ b/src/App/callbacks.cpp @@ -42,11 +42,11 @@ void handleOnoffButtonPress() auto app = Dough::App::Instance(); if (app->state.get() == Dough::MEASURING) { - app->state.pauseMeasurements(); + app->state.pauseDevice(); } else if (app->state.get() == Dough::PAUSED) { - app->state.resumeMeasurements(); + app->state.resumeDevice(); } } diff --git a/src/Sensors/SensorController.cpp b/src/Sensors/SensorController.cpp index 2164eb0..ebb73b1 100644 --- a/src/Sensors/SensorController.cpp +++ b/src/Sensors/SensorController.cpp @@ -8,20 +8,20 @@ namespace Dough SensorControllerPluginBase *plugin, unsigned int storageSize, unsigned int minimumMeasureTime, - unsigned int minimumPublishTime) : _sensor(sensor), + unsigned int minimumPublishTime) : sensor(sensor), _plugin(plugin), _storageSize(storageSize), _minimumMeasureTime(minimumMeasureTime), _minimumPublishTime(minimumPublishTime) {} - const char* SensorController::getSensorName() + const char *SensorController::getSensorName() { - return _sensor->getName(); + return sensor->getName(); } void SensorController::setup() { - _sensor->setup(); + sensor->setup(); // Initialize the storage for holding measurements. This storage is used // as a circular buffer, and it helps in computing an over time average @@ -35,25 +35,30 @@ namespace Dough clearHistory(); } - void SensorController::loop() + bool SensorController::loop() { if (_mustMeasure()) { _plugin->beforeMeasure(this); - _measure(); + _lastMeasuredAt = millis(); + _store(sensor->read()); _plugin->afterMeasure(this); } + + auto last = getLast(); + if (_mustPublish()) { _plugin->beforePublish(this); - auto average = _getAverage(); - auto last = _getLast(); + auto average = getAverage(); _lastPublishedAt = millis(); average.copyTo(&_lastPublishedAverage); last.copyTo(&_lastPublished); _plugin->doPublish(this, last, average); _plugin->afterPublish(this); } + + return last.ok; } bool SensorController::_mustMeasure() @@ -71,16 +76,9 @@ namespace Dough return delta >= (_minimumMeasureTime * 1000); } - void SensorController::_measure() - { - _lastMeasuredAt = millis(); - - _store(_sensor->read()); - } - bool SensorController::_mustPublish() { - Measurement lastMeasurement = _getLast(); + Measurement lastMeasurement = getLast(); // When the measurement failed, then there's no need to publish it. if (lastMeasurement.ok == false) @@ -103,7 +101,7 @@ namespace Dough return _lastPublishedAt == 0 || delta >= (_minimumPublishTime * 1000); } - auto precision = _sensor->getPrecision(); + auto precision = sensor->getPrecision(); // When there is a significant change in the sensor value, then publish. if (abs(_lastPublished.value - lastMeasurement.value) >= precision) @@ -111,7 +109,7 @@ namespace Dough return true; } - auto average = _getAverage(); + auto average = getAverage(); // When there is a significant change in the average value, then publish. if (average.ok && abs(_lastPublishedAverage.value - average.value) >= precision) @@ -164,12 +162,12 @@ namespace Dough return _index; } - Measurement SensorController::_getLast() + Measurement SensorController::getLast() { return *_storage[_index]; } - Measurement SensorController::_getAverage() + Measurement SensorController::getAverage() { return _averageCount > 0 ? Measurement::Value(round(_averageSum / _averageCount)) diff --git a/src/Sensors/SensorController.h b/src/Sensors/SensorController.h index 4218536..3256bb7 100644 --- a/src/Sensors/SensorController.h +++ b/src/Sensors/SensorController.h @@ -54,16 +54,37 @@ namespace Dough unsigned int storageSize, unsigned int minimumMeasureTime, unsigned int minimumPublishTime); - const char *getSensorName(); + SensorBase *sensor; void setup(); - void loop(); + + // Return the name for the contained sensor. + const char *getSensorName(); + + // Read the sensor and publish the results when needed. + // This method returns true when the last read value was an ok measurement. + // This means that after this method returns true, getLast() will return + // an ok Dough::Measurement. + bool loop(); + + // Read a measurement from the sensor. + Measurement readSensor(); + + // Returns the last measurement that was done for the sensor. + // This might be a failed measurement, in which case the ok field + // of the result will be set to false. + Measurement getLast(); + + // Returns the running average value for the sensor readings so far. + // When no successful measurements were done at all, then the ok + // field of the result will be set to false. + Measurement getAverage(); + + // Clear the collected data for the running average, letting the + // average computation start from a clean slate. void clearHistory(); private: - SensorBase *_sensor; SensorControllerPluginBase *_plugin; - Measurement _getLast(); - Measurement _getAverage(); // Members related to the measurement storage. Measurement **_storage; @@ -76,7 +97,6 @@ namespace Dough // Members used for controlling measurements. bool _mustMeasure(); - void _measure(); unsigned int _minimumMeasureTime; unsigned long _lastMeasuredAt = 0;