diff --git a/README.md b/README.md index 2ae9f29..dac8c00 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ Find out more at https://www.sensate.io - Adafruit BME680 (https://github.com/adafruit/Adafruit_BME680 v1.0.7) - Max44009 (https://github.com/dantudose/MAX44009 v1.2.3) - BH1750 (https://github.com/claws/BH1750) +- MQTT Client Library (https://github.com/knolleary/pubsubclient v2.8.0) Windows Users: Use https://github.com/nodemcu/nodemcu-flasher for flashing the firmware. diff --git a/firmware-esp8266.ino b/firmware-esp8266.ino index 1d7874f..831ac98 100644 --- a/firmware-esp8266.ino +++ b/firmware-esp8266.ino @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v31 - Fixed an issue with DHT11 Sensors v30 - Added support for SSD1306 I2C Displays v29 - First Public Release @@ -25,7 +26,7 @@ Display* display = NULL; -int currentVersion = 31; +int currentVersion = 32; boolean printMemory = false; String board = "Generic"; @@ -70,6 +71,7 @@ extern int displayMode; extern uint8_t i2cSDAPort; extern uint8_t i2cSCLPort; +extern MQTT* mqtt; #define tickerInterval 250 #define delayInterval 10000 @@ -153,6 +155,8 @@ void runLoop() { case Init_Configuration: case Operating: loopRestserver(); + if(mqtt!=NULL) + mqtt->loop(); break; } } diff --git a/src/communication/Data.cpp b/src/communication/Data.cpp index 28eca5b..6c69c5d 100644 --- a/src/communication/Data.cpp +++ b/src/communication/Data.cpp @@ -12,36 +12,37 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ #include "Data.h" -Data::Data(long id, float value, String unit) { +Data::Data(Sensor *sensor, float value, String unit) { _type = 1; _valueFloat = value; - _id = id; + _sensor = sensor; _unit = unit; } -Data::Data(long id, int value, String unit) { +Data::Data(Sensor *sensor, int value, String unit) { _type = 2; _valueInt = value; - _id = id; + _sensor = sensor; _unit = unit; } -Data::Data(long id, boolean value, String unit) { +Data::Data(Sensor *sensor, boolean value, String unit) { _type = 3; _valueBoolean = value; - _id = id; + _sensor = sensor; _unit = unit; } String Data::getRequestString() { - String returnString = String(_id) +","; + String returnString = String(_sensor->getId()) +","; if(_type==1) returnString = returnString + String(_valueFloat); @@ -52,4 +53,20 @@ String Data::getRequestString() { return returnString+","+_unit; -} \ No newline at end of file +} + +String Data::getValueString() { + + if(_type==1) + return String(_valueFloat); + else if(_type==2) + return String(_valueInt); + else if(_type==3) + return String(_valueBoolean); + + return ""; +} + +Sensor* Data::getSensor() { + return _sensor; +} \ No newline at end of file diff --git a/src/communication/Data.h b/src/communication/Data.h index 331a2a2..44d4a0c 100644 --- a/src/communication/Data.h +++ b/src/communication/Data.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -20,19 +21,25 @@ #ifndef _Data_h_ #define _Data_h_ +#include "../input/Sensor.h" + +class Sensor; + class Data { private: - long _id; + Sensor *_sensor; float _valueFloat; int _valueInt; boolean _valueBoolean; String _unit; int _type; public: - Data(long, float, String); - Data(long, int, String); - Data(long, boolean, String); - String getRequestString(); + Data(Sensor*, float, String); + Data(Sensor*, int, String); + Data(Sensor*, boolean, String); + String getValueString(void); + String getRequestString(void); + Sensor* getSensor(void); }; #endif \ No newline at end of file diff --git a/src/communication/MQTT.cpp b/src/communication/MQTT.cpp new file mode 100644 index 0000000..f16808e --- /dev/null +++ b/src/communication/MQTT.cpp @@ -0,0 +1,144 @@ +/**************************************************************************/ +/*! + @file MQTT.cpp + @author M. Fegerl (Sensate Digital Solutions GmbH) + @license GPL (see LICENSE file) + The Sensate ESP8266 firmware is used to connect ESP8266 based hardware + with the Sensate Cloud and the Sensate apps. + + ----> https://www.sensate.io + + SOURCE: https://github.com/sensate-io/firmware-esp8266.git + + @section HISTORY + v32 - Added MQTT Support! +*/ +/**************************************************************************/ + +#include "MQTT.h" + +extern unsigned long currentMillis; +boolean enableMQTT; +MQTT *mqtt; + +MQTT::MQTT (char* brokerUrl, long brokerPort, String username, String password) +{ + _username = username; + _password = password; + _brokerPort = brokerPort; + _brokerUrl = String(brokerUrl); + + espClient = WiFiClient(); + pubSubClient = new PubSubClient(espClient); + + clientId = "Sensate-"+getUUID().substring(0,7); + + pubSubClient->setServer(_brokerUrl.c_str(), _brokerPort); + + lastMillis = 0; +} + +MQTT::MQTT (char* brokerUrl, long brokerPort) +{ + _username = "NULL"; + _password = "NULL"; + + clientId = "Sensate-"+getUUID().substring(0,7); + + pubSubClient = new PubSubClient(espClient); + pubSubClient->setServer(brokerUrl, brokerPort); + +} + +bool MQTT::connect() +{ + Serial.println("Connecting to broker with clientId: "+clientId); + + if(_username=="NULL" && _password=="NULL") + { + Serial.println("Connecting to MQTT broker..."); + + if (pubSubClient->connect(clientId.c_str())) + { + Serial.println("Connected to MQTT broker"); + return true; + } + else + { + Serial.print("Connection to MQTT Broker failed with state "); + Serial.print(pubSubClient->state()); + return false; + } + } + else + { + Serial.println("Connecting to MQTT broker with credentials..."); + + if (pubSubClient->connect(clientId.c_str(), _username.c_str(), _password.c_str())) + { + Serial.println("Connected to MQTT broker"); + return true; + } + else + { + Serial.print("Connection to MQTT Broker failed with state "); + Serial.print(pubSubClient->state()); + return false; + } + } +} + +void MQTT::publishForAutoDiscovery(Sensor* sensor) +{ + String pTopic = "homeassistant/sensor/"+clientId+"/"+String(sensor->getId())+"/config"; + String category = sensor->getCategory(); + String pPayload; + + if(category==NULL) + category = "Unnamed"; + + if(sensor->getMqttClass()=="resistance" || sensor->getMqttClass()=="altitude" || sensor->getMqttClass()=="flux" || sensor->getMqttClass()=="") + pPayload = "{\"name\": \""+sensor->getName()+"\", \"state_topic\": \"Sensate/"+category+"/"+sensor->getName()+"/value\", \"unit_of_measurement\": \""+sensor->getMqttUnit()+"\"}"; + else + pPayload = "{\"name\": \""+sensor->getName()+"\", \"device_class\": \""+sensor->getMqttClass()+"\", \"state_topic\": \"Sensate/"+category+"/"+sensor->getName()+"/value\", \"unit_of_measurement\": \""+sensor->getMqttUnit()+"\"}"; + + pubSubClient->publish(pTopic.c_str(), pPayload.c_str()); +} + +void MQTT::loop() +{ + pubSubClient->loop(); +} + +void MQTT::publishSensorData(Data* data[], int dataCount) +{ + boolean republish = false; + + if (!pubSubClient->connected()) { + Serial.println("Trying reconnecting to MQTT broker..."); + republish=connect(); + } + + if((lastMillis == 0) || (currentMillis>lastMillis+300000)) + { + Serial.println("Republish MQTT Sensors (once every 5min)"); + republish=true; + lastMillis = currentMillis; + } + + for (int i = 0; i < dataCount; i++) + { + if(republish) + { + publishForAutoDiscovery(data[i]->getSensor()); + delay(250); + } + + String cat = data[i]->getSensor()->getCategory(); + if(cat.equals("")) + cat="Unnamed"; + String name = data[i]->getSensor()->getName(); + String vTopic = "Sensate/"+cat+"/"+name+"/value"; + pubSubClient->publish(vTopic.c_str(), data[i]->getValueString().c_str()); + } +} diff --git a/src/communication/MQTT.h b/src/communication/MQTT.h new file mode 100644 index 0000000..caceaa6 --- /dev/null +++ b/src/communication/MQTT.h @@ -0,0 +1,48 @@ +/**************************************************************************/ +/*! + @file MQTT.h + @author M. Fegerl (Sensate Digital Solutions GmbH) + @license GPL (see LICENSE file) + The Sensate ESP8266 firmware is used to connect ESP8266 based hardware + with the Sensate Cloud and the Sensate apps. + + ----> https://www.sensate.io + + SOURCE: https://github.com/sensate-io/firmware-esp8266.git + + @section HISTORY + v32 - Added MQTT Support! +*/ +/**************************************************************************/ + +#include +#include +#include + +#ifndef _MQTT_h_ +#define _MQTT_h_ + +#include "../controller/UUID.h" +#include "Data.h" + +class MQTT { + private: + unsigned long lastMillis; + String _brokerUrl; + long _brokerPort; + String _username; + String _password; + WiFiClient espClient; + PubSubClient* pubSubClient; + String clientId; + + public: + MQTT (char*, long); + MQTT (char*, long, String, String); + bool connect(void); + void loop(void); + void publishSensorData(Data* data[], int); + void publishForAutoDiscovery(Sensor*); +}; + +#endif \ No newline at end of file diff --git a/src/communication/RestServer.cpp b/src/communication/RestServer.cpp index a36d942..2a4cef9 100644 --- a/src/communication/RestServer.cpp +++ b/src/communication/RestServer.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -26,6 +27,7 @@ extern const byte DNS_PORT; extern const char *myHostname; extern Display* display; extern String bridgeURL; +extern MQTT* mqtt; void startRestServer() { Serial.println("startRestServer"); @@ -46,6 +48,7 @@ void configRestServerRouting() { http_rest_server.on("/resetbridge", HTTP_GET, resetBridgeConfig); //Remove SSID and Password and restart Device to use SoftAP http_rest_server.on("/uuid", HTTP_GET, restGetUuid); //Welcome and return Device UUID if Hint is correct http_rest_server.on("/updateName", HTTP_PUT, restUpdateName); + http_rest_server.on("/initMqtt", HTTP_PUT, initMqtt); http_rest_server.on("/restart", HTTP_GET,tryRestart); http_rest_server.on("/identify", HTTP_GET,tryIdentify); state=Register; @@ -166,7 +169,110 @@ void restUpdateName() { { http_rest_server.send(400); } - +} + +void initMqtt() { + + Serial.println("initMqtt"); + + String requestUUID = http_rest_server.arg("uuid"); + + if(requestUUID!=NULL && requestUUID.equals(getUUID())) + { + String mqttBrokerUrl = http_rest_server.arg("brokerUrl"); + String mqttBrokerPortString = http_rest_server.arg("brokerPort"); + String mqttUsername = http_rest_server.arg("username"); + String mqttPassword = http_rest_server.arg("password"); + + EEPROM.begin(398); + + if(mqttBrokerUrl!=NULL && mqttBrokerUrl.length()>0) + { + Serial.println("Setting MQTT Broker Url: "+mqttBrokerUrl+" and port: "+mqttBrokerPortString); + + EEPROM.write(314, 114); + EEPROM.write(315, 115); + + yield(); + + char mqttBrokerUrlChars[36]; + mqttBrokerUrl.toCharArray(mqttBrokerUrlChars, 36); + EEPROM.put(316, mqttBrokerUrlChars); + + if(mqttBrokerPortString==NULL || mqttBrokerPortString.length()==0) + { + mqttBrokerPortString = "1883"; + } + + char mqttBrokerPortChars[5]; + mqttBrokerPortString.toCharArray(mqttBrokerPortChars,5); + long mqttBrokerPort = atol(mqttBrokerPortChars); + EEPROM.put(352, mqttBrokerPort); + + if(mqttUsername!=NULL && mqttUsername.length()>0 && mqttPassword!=NULL && mqttPassword.length()>0) + { + Serial.println("Setting mqttAuth User: "+mqttUsername + " and password."); + + EEPROM.write(356, 156); + EEPROM.write(357, 157); + + yield(); + + char mqttUsernameChars[20]; + mqttUsername.toCharArray(mqttUsernameChars, 20); + EEPROM.put(358, mqttUsernameChars); + + char mqttPasswordChars[20]; + mqttPassword.toCharArray(mqttPasswordChars, 20); + + EEPROM.put(378, mqttPasswordChars); + + yield(); + } + else + { + Serial.println("Disabling MQTT Auth."); + + EEPROM.write(356, 0); + EEPROM.write(357, 0); + + mqtt = NULL; + + yield(); + } + + } + else + { + Serial.println("Disabling MQTT."); + + EEPROM.write(314, 0); + EEPROM.write(315, 0); + EEPROM.write(356, 0); + EEPROM.write(357, 0); + + mqtt = NULL; + + yield(); + } + + EEPROM.end(); + + yield(); + + tryInitMQTT(); + + yield(); + + http_rest_server.send(200); + http_rest_server.client().stop(); + + return; + } + + Serial.println("Invalid/missing Bridge Identifier!"); + http_rest_server.send(401); + http_rest_server.client().stop(); } diff --git a/src/communication/RestServer.h b/src/communication/RestServer.h index 16ef013..460d0ec 100644 --- a/src/communication/RestServer.h +++ b/src/communication/RestServer.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -26,6 +27,7 @@ #include "../controller/UUID.h" #include "../output/display/DisplayOLED128.h" #include "../communication/WiFiManager.h" +#include "MQTT.h" void startRestServer(); void loopRestserver(); @@ -42,6 +44,7 @@ void presentWiFiSetupScreen(); void tryRestart(); void restUpdateName(); void handleAppleCaptivePortal(); +void initMqtt(); String toStringIp(IPAddress ip); bool isIp(String str); diff --git a/src/controller/Bridge.cpp b/src/controller/Bridge.cpp index 0da5af8..40d45b7 100644 --- a/src/controller/Bridge.cpp +++ b/src/controller/Bridge.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -43,6 +44,9 @@ extern long powerOnDelay; extern String powerSavePort; extern boolean invPowerSavePort; +extern boolean enableMQTT; +extern MQTT* mqtt; + uint8_t i2cSDAPort; uint8_t i2cSCLPort; @@ -437,6 +441,8 @@ void configureBridge(JsonObject& bridgeConfig) { int newRotation = bridgeConfig["dr"]; + enableMQTT = bridgeConfig["me"]; + if(displayRotation!=newRotation) { displayRotation = newRotation; @@ -478,6 +484,8 @@ void configureBridge(JsonObject& bridgeConfig) { Wire.begin(i2cSDAPort, i2cSCLPort); } } + + tryInitMQTT(); storeDisplayAndPowerConfig(true); @@ -538,6 +546,60 @@ void storeDisplayAndPowerConfig(boolean withPowerSettings) { yield(); } +void tryInitMQTT() { + + if(!enableMQTT) + return; + + Serial.println("Trying to init MQTT client..."); + + EEPROM.begin(398); + + int val314 = EEPROM.read(314); + int val315 = EEPROM.read(315); + + if(val314 == 114 && val315 == 115) + { + char brokerUrl[36]; + EEPROM.get(316, brokerUrl); + long brokerPort; + EEPROM.get(352, brokerPort); + + int val356 = EEPROM.read(356); + int val357 = EEPROM.read(357); + + if(val356 == 156 && val357 == 157) + { + Serial.println("Starting Authenticated MQTT Broker connection..."); + + char username[20]; + EEPROM.get(358, username); + char password[20]; + EEPROM.get(378, password); + + mqtt = new MQTT(brokerUrl, brokerPort, String(username), String(password)); + } + else + { + Serial.println(val356); + Serial.println(val357); + Serial.println("Starting Anonymous MQTT Broker connection..."); + mqtt = new MQTT(brokerUrl, brokerPort); + } + + mqtt->connect(); + } + else + { + Serial.println("No MQTT Broker configured."); + } + + EEPROM.end(); + + yield(); + +} + void configureExpansionPort(int portNumber, JsonObject& portConfig) { Serial.println("Configure Expansion Port: "); @@ -605,36 +667,36 @@ void configureExpansionPort(int portNumber, JsonObject& portConfig) { if (portConfig["et"] == "ADS1015" || portConfig["et"] == "ADS1115") { - addSensor(new Ads1x15 (portConfig["id"], portConfig["sn"], portConfig["n"], portConfig["et"], portConfig["ec1"], portConfig["ch"], portConfig["c1"], portConfig["c2"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new Ads1x15 (portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["et"], portConfig["ec1"], portConfig["ch"], portConfig["c1"], portConfig["c2"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } else if (portConfig["et"] == "DALLAS" || portConfig["et"] == "DS18B20") { uint8_t port = translateGPIOPort(portConfig["ec1"]); - addSensor(new SensorDallas(portConfig["id"], portConfig["sn"], portConfig["n"], port, portConfig["ch"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorDallas(portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], port, portConfig["ch"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } else if (portConfig["et"] == "DHT11" || portConfig["et"] == "DHT21" || portConfig["et"] == "DHT22") { uint8_t port = translateGPIOPort(portConfig["ec1"]); if(port>=0) { - addSensor(new SensorDHT(portConfig["id"], portConfig["et"], portConfig["sn"], portConfig["n"], port, portConfig["s"]["cf"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorDHT(portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["et"], port, refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } } else if (portConfig["et"] == "BME280" || portConfig["et"] == "BMP280") { - addSensor(new SensorBMx280(portConfig["id"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], portConfig["s"]["cf"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorBMx280(portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["ec1"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } else if (portConfig["et"] == "BME680") { - addSensor(new SensorBME680(portConfig["id"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], portConfig["s"]["cf"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorBME680(portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } else if (portConfig["et"] == "MAX44009") { - addSensor(new SensorMax44009(portConfig["id"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], portConfig["s"]["cf"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorMax44009(portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } else if (portConfig["et"] == "BH1750") { - addSensor(new SensorBH1750(portConfig["id"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], portConfig["s"]["cf"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorBH1750(portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["ec1"], portConfig["ec2"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } } @@ -708,11 +770,11 @@ void configurePort(int portNumber, JsonObject& portConfig) { { if(portConfig["c1"]!=0 && portConfig["c2"]==0) { - addSensor(new SensorAnalogue (portConfig["id"], portConfig["sn"], portConfig["n"], portConfig["c1"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorAnalogue (portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], portConfig["c1"], refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } else { - addSensor(new SensorAnalogue (portConfig["id"], portConfig["sn"], portConfig["n"], 0, refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); + addSensor(new SensorAnalogue (portConfig["id"], portConfig["c"], portConfig["sn"], portConfig["n"], 0, refreshInterval, postDataInterval, portConfig["s"]["svt"], calc)); } } } @@ -770,6 +832,10 @@ void loopSensor(int currentTimeMs) { submitSuccess = postSensorData(data, dataCount); abortDelay = submitSuccess; yield(); + if(mqtt!=NULL) + { + mqtt->publishSensorData(data, dataCount); + } } else { diff --git a/src/controller/Bridge.h b/src/controller/Bridge.h index f903ab1..b10cf1e 100644 --- a/src/controller/Bridge.h +++ b/src/controller/Bridge.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -24,6 +25,7 @@ #include "StateHelper.h" #include "UUID.h" #include "../communication/WiFiManager.h" +#include "../communication/MQTT.h" #include "../input/Sensor.h" #include "../input/analog/SensorAnalogue.h" #include "../input/i2c/Ads1x15.h" @@ -40,17 +42,18 @@ void restoreBridgeConfig(); void restart(); bool getBridgeConfig(); -void configureBridge(JsonObject& bridgeConfig); -void configureExpansionPort(int portNumber, JsonObject& portConfig); -void configurePort(int portNumber, JsonObject& portConfig); -void addSensor(Sensor *sensor); -void loopSensor(int currentTimeMs); -boolean postSensorData(Data* data[], int dataCount); +void configureBridge(JsonObject&); +void configureExpansionPort(int, JsonObject&); +void configurePort(int, JsonObject&); +void addSensor(Sensor *); +void loopSensor(int); +boolean postSensorData(Data* data[], int); void checkStatus(); -void trySleep(long microseconds); -void storeDisplayAndPowerConfig(boolean withPowerSettings); +void trySleep(long); +void storeDisplayAndPowerConfig(boolean); void doPowerSaving(); -void doPowerSavingInit(boolean doDelay); -uint8_t translateGPIOPort(String gpioPort); +void doPowerSavingInit(boolean); +uint8_t translateGPIOPort(String); +void tryInitMQTT(); #endif \ No newline at end of file diff --git a/src/input/Sensor.cpp b/src/input/Sensor.cpp index 2b61245..77450cd 100644 --- a/src/input/Sensor.cpp +++ b/src/input/Sensor.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -19,13 +20,14 @@ extern unsigned long nextSensorDue; -Sensor::Sensor (long id, String shortName, String name, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) { +Sensor::Sensor (long id, String category, String shortName, String name, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) { lastTick = -1; lastPost = -1; _refreshInterval = refreshInterval; _postDataInterval = postDataInterval; _name = name; _shortName = shortName; + _category = category; _id = id; _calculation = calculation; _smartValueThreshold = smartValueThreshold; @@ -39,6 +41,10 @@ int Sensor::getPostDataInterval() { return _postDataInterval; } +String Sensor::getCategory() { + return _category; +} + String Sensor::getShortName() { return _shortName; } @@ -47,24 +53,34 @@ String Sensor::getName() { return _name; } +String Sensor::getMqttClass() { + +if(_calculation==NULL) + return "unknown"; + + return _calculation->getValueType(); +} + +String Sensor::getMqttUnit() { + if(_calculation==NULL) + return "?"; + + return _calculation->getValueUnit(); +} + long Sensor::getId() { return _id; } void Sensor::preCycle(int cycleId) { - Serial.println("Base Sensor Pre Cycle"); + Serial.println("Base Sensor Pre Cycle: " + String(cycleId)); } Data* Sensor::read(bool shouldPostData) { Serial.println("Base Sensor Read: " + getName()); } -void Sensor::postCycle(int cycleId) -{ - Serial.println("Base Sensor Post Cycle"); -} - Data* Sensor::trySensorRead(unsigned long currentTimeMillis, int cycleId) { if (lastTick==-1 || currentTimeMillis < lastTick) @@ -79,23 +95,28 @@ Data* Sensor::trySensorRead(unsigned long currentTimeMillis, int cycleId) { Data* Sensor::forceSensorRead(unsigned long currentTimeMillis, int cycleId) { + preCycle(cycleId); + bool shouldPostData = false; if(lastPost==-1 || (lastPost + _postDataInterval <= currentTimeMillis)) { shouldPostData = true; - lastPost = currentTimeMillis; } - - preCycle(cycleId); + Data *d = read(shouldPostData); lastTick = currentTimeMillis; - postCycle(cycleId); - + if(shouldPostData) + { + if (d!=NULL) + { + lastPost = currentTimeMillis; + } + } + if(nextSensorDue==-1 || nextSensorDue < currentTimeMillis || (nextSensorDue > currentTimeMillis+_postDataInterval)) { nextSensorDue = currentTimeMillis+_postDataInterval; } - return d; diff --git a/src/input/Sensor.h b/src/input/Sensor.h index c67dc01..99667a3 100644 --- a/src/input/Sensor.h +++ b/src/input/Sensor.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -20,9 +21,11 @@ #ifndef _Sensor_h_ #define _Sensor_h_ -#include "sensorCalculation.h" +#include "SensorCalculation.h" #include "../communication/Data.h" +class SensorCalculation; + class Sensor { protected: unsigned int _refreshInterval; @@ -30,20 +33,23 @@ class Sensor { float _smartValueThreshold; unsigned long lastTick; unsigned long lastPost; + String _category; String _name; String _shortName; long _id; SensorCalculation* _calculation; virtual void preCycle(int); virtual Data* read(bool); - virtual void postCycle(int); public: - Sensor (long, String, String, int, int, float, SensorCalculation*); + Sensor (long, String, String, String, int, int, float, SensorCalculation*); int getRefreshInterval(void); int getPostDataInterval(void); long getId(void); String getName(void); String getShortName(void); + String getCategory(void); + String getMqttClass(void); + String getMqttUnit(void); Data* trySensorRead(unsigned long, int); Data* forceSensorRead(unsigned long, int); }; diff --git a/src/input/SensorCalculation.cpp b/src/input/SensorCalculation.cpp index 78e6e81..6469c79 100644 --- a/src/input/SensorCalculation.cpp +++ b/src/input/SensorCalculation.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -19,10 +20,26 @@ extern Display* display; -#define SEALEVELPRESSURE_HPA (1013.25) +SensorCalculation::SensorCalculation() +{ + +} + +String SensorCalculation::getValueType() +{ + return _valueType; +} + +String SensorCalculation::getValueUnit() +{ + return _valueUnit; +} -SensorCalculationApproxQuad::SensorCalculationApproxQuad(double calcValue1, double calcValue2, double calcValue3, double calcValue4, int portNumber) +SensorCalculationApproxQuad::SensorCalculationApproxQuad(double calcValue1, double calcValue2, double calcValue3, double calcValue4, int portNumber) : SensorCalculation() { + _valueType = "temperature"; + _valueUnit = "°C"; + _portNumber = portNumber; _calcValue1 = calcValue1; _calcValue2 = calcValue2; @@ -30,252 +47,288 @@ SensorCalculationApproxQuad::SensorCalculationApproxQuad(double calcValue1, doub _calcValue4 = calcValue4; } -SensorCalculationPT1001000::SensorCalculationPT1001000(double r0, int portNumber) +SensorCalculationPT1001000::SensorCalculationPT1001000(double r0, int portNumber) : SensorCalculation() { + _valueType = "temperature"; + _valueUnit = "°C"; + a = 0.0039083; b = -0.0000005775; _portNumber = portNumber; _r0 = r0; } -SensorCalculationDualNtc::SensorCalculationDualNtc(double calcValue1, double calcValue2, int portNumber) +SensorCalculationDualNtc::SensorCalculationDualNtc(double calcValue1, double calcValue2, int portNumber) : SensorCalculation() { + _valueType = "temperature"; + _valueUnit = "°C"; + _portNumber = portNumber; _calcValue1 = calcValue1; _calcValue2 = calcValue2; } -SensorCalculationDirectKelvin::SensorCalculationDirectKelvin(int portNumber) +SensorCalculationDirectKelvin::SensorCalculationDirectKelvin(int portNumber) : SensorCalculation() { + _valueType = "temperature"; + _valueUnit = "K"; + _portNumber = portNumber; } -SensorCalculationDirectCelsius::SensorCalculationDirectCelsius(int portNumber) +SensorCalculationDirectCelsius::SensorCalculationDirectCelsius(int portNumber) : SensorCalculation() { + _valueType = "temperature"; + _valueUnit = "°C"; _portNumber = portNumber; } -SensorCalculationDirectPercent::SensorCalculationDirectPercent(int portNumber) +SensorCalculationDirectPercent::SensorCalculationDirectPercent(int portNumber) : SensorCalculation() { + _valueType = "humidity"; + _valueUnit = "%"; _portNumber = portNumber; } -SensorCalculationDirectHektoPascal::SensorCalculationDirectHektoPascal(int portNumber) +SensorCalculationDirectHektoPascal::SensorCalculationDirectHektoPascal(int portNumber) : SensorCalculation() { + _valueType = "pressure"; + _valueUnit = "hPa"; _portNumber = portNumber; } -SensorCalculationDirectMeter::SensorCalculationDirectMeter(int portNumber) +SensorCalculationDirectMeter::SensorCalculationDirectMeter(int portNumber) : SensorCalculation() { + _valueType = ""; + _valueUnit = "m"; _portNumber = portNumber; } -SensorCalculationDirectLux::SensorCalculationDirectLux(int portNumber) +SensorCalculationDirectLux::SensorCalculationDirectLux(int portNumber) : SensorCalculation() { + _valueType = "illuminance"; + _valueUnit = "lx"; _portNumber = portNumber; } -SensorCalculationDirectLumen::SensorCalculationDirectLumen(int portNumber) +SensorCalculationDirectLumen::SensorCalculationDirectLumen(int portNumber) : SensorCalculation() { + _valueType = "flux"; + _valueUnit = "lm"; _portNumber = portNumber; } -SensorCalculationDirectOhm::SensorCalculationDirectOhm(int portNumber) +SensorCalculationDirectOhm::SensorCalculationDirectOhm(int portNumber) : SensorCalculation() { + _valueType = "resistance"; + _valueUnit = "Ohm"; _portNumber = portNumber; } -SensorCalculationDirectKOhm::SensorCalculationDirectKOhm(int portNumber) +SensorCalculationDirectKOhm::SensorCalculationDirectKOhm(int portNumber) : SensorCalculation() { + _valueType = "resistance"; + _valueUnit = "kOhm"; _portNumber = portNumber; } -SensorCalculationDirectPPM::SensorCalculationDirectPPM(int portNumber) +SensorCalculationDirectPPM::SensorCalculationDirectPPM(int portNumber) : SensorCalculation() { + _valueType = "concentration"; + _valueUnit = "ppm"; _portNumber = portNumber; } -SensorCalculationDirectNone::SensorCalculationDirectNone(int portNumber) +SensorCalculationDirectNone::SensorCalculationDirectNone(int portNumber) : SensorCalculation() { + _valueType = "unknown"; + _valueUnit = ""; _portNumber = portNumber; } - -SensorCalculationCalcAltitude::SensorCalculationCalcAltitude(int portNumber) +SensorCalculationCalcAltitude::SensorCalculationCalcAltitude(int portNumber) : SensorCalculation() { + _valueType = "altitude"; + _valueUnit = "m"; _portNumber = portNumber; } -SensorCalculationRawToPercent::SensorCalculationRawToPercent(float calcValue1, float calcValue2, int portNumber) +SensorCalculationRawToPercent::SensorCalculationRawToPercent(float calcValue1, float calcValue2, int portNumber) : SensorCalculation() { + _valueType = "humidity"; + _valueUnit = "%"; _portNumber = portNumber; _calcValue1 = calcValue1; _calcValue2 = calcValue2; } -SensorCalculationRaw::SensorCalculationRaw(int portNumber) +SensorCalculationRaw::SensorCalculationRaw(int portNumber) : SensorCalculation() { + _valueType = "raw"; + _valueUnit = "(raw))"; _portNumber = portNumber; } +Data* SensorCalculation::calculate(Sensor* sensor, float rawValue, bool postData) +{ + return NULL; +} -Data* SensorCalculationApproxQuad::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationApproxQuad::calculate(Sensor* sensor, float rawValue, bool postData) { double v = log( (double)rawValue / _calcValue4); double z = _calcValue1 + (_calcValue2 * v) + (_calcValue3 * v * v); - float tempInK = (float) (1 / z); + float tempInC = (float) ((float) (1 / z) - 273.15); if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, tempInK, "K"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), tempInC, _valueUnit); if(!postData) return NULL; - return new Data (id, tempInK, "KELVIN"); + return new Data (sensor, tempInC, "CELSIUS"); } -Data* SensorCalculationPT1001000::calculate(long id, String name, String shortName, float rT, bool postData) +Data* SensorCalculationPT1001000::calculate(Sensor* sensor, float rT, bool postData) { double v2 = _r0*_r0*a*a; double v3 = 4*_r0*b*(_r0-rT); double v4 = sqrt(v2-v3); double v5 = 2*_r0*b; - double tempInC = (-_r0*a+v4)/v5; - float tempInK = (float) (tempInC + 273.15); + float tempInC = (float)(-_r0*a+v4)/v5; if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, tempInC, "°C"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), tempInC, _valueUnit); if(!postData) return NULL; - return new Data (id, tempInK, "KELVIN"); + return new Data (sensor, tempInC, "CELSIUS"); } -Data* SensorCalculationDualNtc::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDualNtc::calculate(Sensor* sensor, float rawValue, bool postData) { double x = 0.003354016; double y = log(rawValue / _calcValue2); double z = y / _calcValue1; - float tempInK = (float) (1.0 / (z + x)); + float tempInC = (float) ((1.0 / (z + x))- 273.15); if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, tempInK, "K"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), tempInC, _valueUnit); if(!postData) return NULL; - return new Data (id, tempInK, "KELVIN"); + return new Data (sensor, tempInC, "CELSIUS"); } -Data* SensorCalculationDirectKelvin::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectKelvin::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "K"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "KELVIN"); + return new Data (sensor, rawValue, "KELVIN"); } -Data* SensorCalculationDirectCelsius::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectCelsius::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "°C"); - float tempInK = rawValue+273.15; + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, tempInK, "KELVIN"); + return new Data (sensor, rawValue, "CELSIUS"); } -Data* SensorCalculationDirectPercent::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectPercent::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "%"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "PERCENT"); + return new Data (sensor, rawValue, "PERCENT"); } -Data* SensorCalculationDirectHektoPascal::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectHektoPascal::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "hPa"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "HEKTOPASCAL"); + return new Data (sensor, rawValue, "HEKTOPASCAL"); } -Data* SensorCalculationDirectMeter::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectMeter::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "m"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "METER"); + return new Data (sensor, rawValue, "METER"); } -Data* SensorCalculationDirectLux::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectLux::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "lx"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "LUX"); + return new Data (sensor, rawValue, "LUX"); } -Data* SensorCalculationDirectLumen::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectLumen::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "lm"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "LUMEN"); + return new Data (sensor, rawValue, "LUMEN"); } -Data* SensorCalculationDirectOhm::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectOhm::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "Ohm"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "OHM"); + return new Data (sensor, rawValue, "OHM"); } -Data* SensorCalculationDirectKOhm::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectKOhm::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "kOhm"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "KOHM"); + return new Data (sensor, rawValue, "KOHM"); } -Data* SensorCalculationDirectPPM::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectPPM::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "ppm"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "PPM"); + return new Data (sensor, rawValue, "PPM"); } -Data* SensorCalculationDirectNone::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationDirectNone::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, ""); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "NONE"); + return new Data (sensor, rawValue, "NONE"); } -Data* SensorCalculationCalcAltitude::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationCalcAltitude::calculate(Sensor* sensor, float rawValue, bool postData) { - float altitude = 44330.0 * (1.0 - pow(rawValue / SEALEVELPRESSURE_HPA, 0.1903)); + float altitude = 44330.0 * (1.0 - pow(rawValue / 1013.25, 0.1903)); if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, altitude, "m"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), altitude, _valueUnit); if(!postData) return NULL; - return new Data (id, altitude, "METER"); + return new Data (sensor, altitude, "METER"); } -Data* SensorCalculationRawToPercent::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationRawToPercent::calculate(Sensor* sensor, float rawValue, bool postData) { float min = _calcValue1; float max = _calcValue2; @@ -287,17 +340,17 @@ Data* SensorCalculationRawToPercent::calculate(long id, String name, String shor if(percent>100) percent = 100.0; if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, percent, "%"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), percent, _valueUnit); if(!postData) return NULL; - return new Data (id, percent, "PERCENT"); + return new Data (sensor, percent, "PERCENT"); } -Data* SensorCalculationRaw::calculate(long id, String name, String shortName, float rawValue, bool postData) +Data* SensorCalculationRaw::calculate(Sensor* sensor, float rawValue, bool postData) { if(display!=NULL && _portNumber>=0) - display->drawValue(_portNumber, name, shortName, rawValue, "(raw)"); + display->drawValue(_portNumber, sensor->getName(), sensor->getShortName(), rawValue, _valueUnit); if(!postData) return NULL; - return new Data (id, rawValue, "UNKNOWN"); + return new Data (sensor, rawValue, "UNKNOWN"); } \ No newline at end of file diff --git a/src/input/SensorCalculation.h b/src/input/SensorCalculation.h index b98426e..4c4ddad 100644 --- a/src/input/SensorCalculation.h +++ b/src/input/SensorCalculation.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -19,16 +20,24 @@ #include #ifndef _SensorCalculation_h_ -#define __SensorCalculation_h_ +#define _SensorCalculation_h_ -#include "../communication/Data.h" +#include "Sensor.h" #include "../output/display/DisplayOLED128.h" +class Data; +class Sensor; + class SensorCalculation { protected: int _portNumber; + String _valueType; + String _valueUnit; public: - virtual Data* calculate(long, String, String, float, bool); + String getValueType(); + String getValueUnit(); + SensorCalculation(); + virtual Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationApproxQuad : public SensorCalculation { @@ -36,7 +45,7 @@ class SensorCalculationApproxQuad : public SensorCalculation { double _calcValue1,_calcValue2,_calcValue3,_calcValue4; public: SensorCalculationApproxQuad(double, double, double, double, int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationPT1001000 : public SensorCalculation { @@ -44,7 +53,7 @@ class SensorCalculationPT1001000 : public SensorCalculation { double _r0, a, b; public: SensorCalculationPT1001000(double, int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDualNtc : public SensorCalculation { @@ -52,79 +61,79 @@ class SensorCalculationDualNtc : public SensorCalculation { double _calcValue1,_calcValue2; public: SensorCalculationDualNtc(double, double, int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectKelvin : public SensorCalculation { public: SensorCalculationDirectKelvin(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectCelsius : public SensorCalculation { public: SensorCalculationDirectCelsius(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectPercent : public SensorCalculation { public: SensorCalculationDirectPercent(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectHektoPascal : public SensorCalculation { public: SensorCalculationDirectHektoPascal(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectMeter : public SensorCalculation { public: SensorCalculationDirectMeter(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectLux : public SensorCalculation { public: SensorCalculationDirectLux(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectLumen : public SensorCalculation { public: SensorCalculationDirectLumen(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectNone : public SensorCalculation { public: SensorCalculationDirectNone(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectOhm : public SensorCalculation { public: SensorCalculationDirectOhm(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectKOhm : public SensorCalculation { public: SensorCalculationDirectKOhm(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationDirectPPM : public SensorCalculation { public: SensorCalculationDirectPPM(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationCalcAltitude : public SensorCalculation { public: SensorCalculationCalcAltitude(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationRawToPercent : public SensorCalculation { @@ -132,13 +141,13 @@ class SensorCalculationRawToPercent : public SensorCalculation { float _calcValue1,_calcValue2; public: SensorCalculationRawToPercent(float, float, int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; class SensorCalculationRaw : public SensorCalculation { public: SensorCalculationRaw(int); - Data* calculate(long, String, String, float, bool); + Data* calculate(Sensor* sensor, float, bool); }; #endif \ No newline at end of file diff --git a/src/input/analog/SensorAnalogue.cpp b/src/input/analog/SensorAnalogue.cpp index bbe0fe9..7945216 100644 --- a/src/input/analog/SensorAnalogue.cpp +++ b/src/input/analog/SensorAnalogue.cpp @@ -12,6 +12,7 @@ @section HISTORY v29 - First Public Release + v32 - Added MQTT Support! */ /**************************************************************************/ @@ -20,11 +21,11 @@ extern boolean isResetting; extern int powerMode; -SensorAnalogue::SensorAnalogue (long id, String shortName, String name, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorAnalogue::SensorAnalogue (long id, String category, String shortName, String name, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { } -SensorAnalogue::SensorAnalogue (long id, String shortName, String name, int rSplit, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorAnalogue::SensorAnalogue (long id, String category, String shortName, String name, int rSplit, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { _rSplit = rSplit; @@ -53,12 +54,12 @@ Data* SensorAnalogue::read(bool shouldPostData) { double rT = ((double) adc)*_rSplit/(1024-adc); shouldPostData = smartSensorCheck(rT, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, rT, shouldPostData); + return _calculation->calculate(this, rT, shouldPostData); } else { shouldPostData = smartSensorCheck(adc, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, adc, shouldPostData); + return _calculation->calculate(this, adc, shouldPostData); } } } @@ -87,9 +88,4 @@ boolean SensorAnalogue::smartSensorCheck(float currentRawValue, float threshhold } return shouldPostData; - -} - -void SensorAnalogue::postCycle(int cycleId) -{ } \ No newline at end of file diff --git a/src/input/analog/SensorAnalogue.h b/src/input/analog/SensorAnalogue.h index a912182..946b1cf 100644 --- a/src/input/analog/SensorAnalogue.h +++ b/src/input/analog/SensorAnalogue.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -28,11 +29,10 @@ class SensorAnalogue : public Sensor { protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: - SensorAnalogue (long, String, String, int, int, float, SensorCalculation*); - SensorAnalogue (long, String, String, int, int, int, float, SensorCalculation*); + SensorAnalogue (long, String, String, String, int, int, float, SensorCalculation*); + SensorAnalogue (long, String, String, String, int, int, int, float, SensorCalculation*); }; #endif \ No newline at end of file diff --git a/src/input/i2c/Ads1x15.cpp b/src/input/i2c/Ads1x15.cpp index 38be50b..72c2a95 100644 --- a/src/input/i2c/Ads1x15.cpp +++ b/src/input/i2c/Ads1x15.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -28,7 +29,7 @@ Adafruit_ADS1015* Ads1x15::ads1x15_4B = NULL; extern int powerMode; -Ads1x15::Ads1x15 (long id, String shortName, String name, String type, String addressString, int channel, int preResistor, int postResistor, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +Ads1x15::Ads1x15 (long id, String category, String shortName, String name, String type, String addressString, int channel, int preResistor, int postResistor, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { _channel = channel; numberOfSamples = 10; @@ -110,7 +111,7 @@ Data* Ads1x15::read(bool shouldPostData) { adc = adc/adcMax*1024; shouldPostData = smartSensorCheck(adc, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, adc, shouldPostData); + return _calculation->calculate(this, adc, shouldPostData); } else { @@ -125,7 +126,7 @@ Data* Ads1x15::read(bool shouldPostData) { // Serial.printf("Corrected res: %f\n\r",res); shouldPostData = smartSensorCheck(res, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, res, shouldPostData); + return _calculation->calculate(this, res, shouldPostData); } } @@ -154,9 +155,4 @@ boolean Ads1x15::smartSensorCheck(float currentRawValue, float threshhold, boole return shouldPostData; -} - -void Ads1x15::postCycle(int cycleId) -{ - } \ No newline at end of file diff --git a/src/input/i2c/Ads1x15.h b/src/input/i2c/Ads1x15.h index 66889ab..4ce8b4c 100644 --- a/src/input/i2c/Ads1x15.h +++ b/src/input/i2c/Ads1x15.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -40,10 +41,9 @@ class Ads1x15 : public Sensor { protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: - Ads1x15 (long, String, String, String, String, int, int, int, int, int, float, SensorCalculation*); + Ads1x15 (long, String, String, String, String, String, int, int, int, int, int, float, SensorCalculation*); }; #endif \ No newline at end of file diff --git a/src/input/i2c/SensorBH1750.cpp b/src/input/i2c/SensorBH1750.cpp index 5a715b7..0c5168e 100644 --- a/src/input/i2c/SensorBH1750.cpp +++ b/src/input/i2c/SensorBH1750.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -22,7 +23,7 @@ extern int powerMode; BH1750* SensorBH1750::bh1750; -SensorBH1750::SensorBH1750 (long id, String shortName, String name, String PortSDA, String PortSCL, String calcType, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorBH1750::SensorBH1750 (long id, String category, String shortName, String name, String PortSDA, String PortSCL, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { if(bh1750==NULL) { @@ -30,9 +31,6 @@ SensorBH1750::SensorBH1750 (long id, String shortName, String name, String PortS bh1750->begin(); } - - _calcType = calcType; - } void SensorBH1750::preCycle(int cycleId) @@ -43,14 +41,14 @@ Data* SensorBH1750::read(bool shouldPostData) { if(!isResetting) { - if(_calcType=="DIRECT_LUX") + if(_calculation->getValueType()=="illuminance") { float illuminance = bh1750->readLightLevel(); if(illuminance>=0) { shouldPostData = smartSensorCheck(illuminance, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, illuminance, shouldPostData); + return _calculation->calculate(this, illuminance, shouldPostData); } else Serial.println("NAN Illuminance!"); @@ -81,9 +79,4 @@ boolean SensorBH1750::smartSensorCheck(float currentRawValue, float threshhold, return shouldPostData; -} - -void SensorBH1750::postCycle(int cycleId) -{ - } \ No newline at end of file diff --git a/src/input/i2c/SensorBH1750.h b/src/input/i2c/SensorBH1750.h index ebf2696..ebc7c9a 100644 --- a/src/input/i2c/SensorBH1750.h +++ b/src/input/i2c/SensorBH1750.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -26,12 +27,10 @@ class SensorBH1750 : public Sensor { private: static BH1750 *bh1750; - String _calcType; float lastPostedValue = NAN; protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: SensorBH1750 (long, String, String, String, String, String, int, int, float, SensorCalculation*); diff --git a/src/input/i2c/SensorBME680.cpp b/src/input/i2c/SensorBME680.cpp index dd9aa7f..9842dd8 100644 --- a/src/input/i2c/SensorBME680.cpp +++ b/src/input/i2c/SensorBME680.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -28,7 +29,7 @@ int SensorBME680::lastReadCycleId = 0; #define BME_MOSI 11 #define BME_CS 10 -SensorBME680::SensorBME680 (long id, String shortName, String name, String PortSDA, String PortSCL, String calcType, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorBME680::SensorBME680 (long id, String category, String shortName, String name, String PortSDA, String PortSCL, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { if(bme == NULL) { @@ -65,9 +66,6 @@ SensorBME680::SensorBME680 (long id, String shortName, String name, String PortS bme->setGasHeater(320, 500); // 320*C for 500 ms } } - - _calcType = calcType; - } void SensorBME680::preCycle(int cycleId) @@ -102,37 +100,39 @@ Data* SensorBME680::read(bool shouldPostData) { if(!isResetting && bme != NULL) { - if(_calcType=="DIRECT_PERCENT") + if(_calculation->getValueType()=="humidity") { float humidity = bme->humidity; shouldPostData = smartSensorCheck(humidity, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, humidity, shouldPostData); + return _calculation->calculate(this, humidity, shouldPostData); } - else if(_calcType=="DIRECT_CELSIUS") + else if(_calculation->getValueType()=="temperature") { float tempC = bme->temperature; shouldPostData = smartSensorCheck(tempC, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, tempC, shouldPostData); + return _calculation->calculate(this, tempC, shouldPostData); } - else if(_calcType=="DIRECT_HEKTOPASCAL") + else if(_calculation->getValueType()=="pressure") { float pressure = bme->pressure/100.0; shouldPostData = smartSensorCheck(pressure, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, pressure, shouldPostData); - } - else if(_calcType=="DIRECT_OHM") - { - float resistance = bme->gas_resistance; - shouldPostData = smartSensorCheck(resistance, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, resistance, shouldPostData); + return _calculation->calculate(this, pressure, shouldPostData); } - else if(_calcType=="DIRECT_KOHM") - { - float resistance = bme->gas_resistance/1000.0; - shouldPostData = smartSensorCheck(resistance, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, resistance, shouldPostData); + else if(_calculation->getValueType()=="resistance") + { + if(_calculation->getValueUnit()=="Ohm") + { + float resistance = bme->gas_resistance; + shouldPostData = smartSensorCheck(resistance, _smartValueThreshold, shouldPostData); + return _calculation->calculate(this, resistance, shouldPostData); + } + else if(_calculation->getValueUnit()=="kOhm") + { + float resistance = bme->gas_resistance/1000.0; + shouldPostData = smartSensorCheck(resistance, _smartValueThreshold, shouldPostData); + return _calculation->calculate(this, resistance, shouldPostData); + } } - } return NULL; @@ -159,13 +159,4 @@ boolean SensorBME680::smartSensorCheck(float currentRawValue, float threshhold, return shouldPostData; -} - -void SensorBME680::postCycle(int cycleId) -{ - for(int i = 0; i<10; i++) - { - yield(); - delay(100); - } } \ No newline at end of file diff --git a/src/input/i2c/SensorBME680.h b/src/input/i2c/SensorBME680.h index 0ad4474..27db0c2 100644 --- a/src/input/i2c/SensorBME680.h +++ b/src/input/i2c/SensorBME680.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -27,12 +28,10 @@ class SensorBME680 : public Sensor { private: static Adafruit_BME680* bme; static int lastReadCycleId; - String _calcType; float lastPostedValue = NAN; protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: SensorBME680 (long, String, String, String, String, String, int, int, float, SensorCalculation*); diff --git a/src/input/i2c/SensorBMx280.cpp b/src/input/i2c/SensorBMx280.cpp index d5da3d1..2a1aa9a 100644 --- a/src/input/i2c/SensorBMx280.cpp +++ b/src/input/i2c/SensorBMx280.cpp @@ -11,27 +11,51 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ #include "SensorBMx280.h" +#include "Wire.h" extern boolean isResetting; extern int powerMode; -BME280I2C* SensorBMx280::bme = NULL; +BME280I2C* SensorBMx280::bme76 = NULL; +BME280I2C* SensorBMx280::bme77 = NULL; -SensorBMx280::SensorBMx280 (long id, String shortName, String name, String PortSDA, String PortSCL, String calcType, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorBMx280::SensorBMx280 (long id, String category, String shortName, String name, String i2cAdress, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { BME280::TempUnit tempUnit(BME280::TempUnit_Celsius); BME280::PresUnit presUnit(BME280::PresUnit_hPa); - if(bme == NULL) + if(i2cAdress=="0x77") { - bme = new BME280I2C(); + if(bme77 == NULL) + { + BME280I2C::Settings settings( + BME280::OSR_X1, + BME280::OSR_X1, + BME280::OSR_X1, + BME280::Mode_Forced, + BME280::StandbyTime_1000ms, + BME280::Filter_16, + BME280::SpiEnable_False, + 0x77 + ); + bme77 = new BME280I2C(settings); + } + bme = bme77; + } + else + { + if(bme76 == NULL) + { + bme76 = new BME280I2C(); + } + bme = bme76; } - int i=0; @@ -49,9 +73,6 @@ SensorBMx280::SensorBMx280 (long id, String shortName, String name, String PortS i++; } - - _calcType = calcType; - } void SensorBMx280::preCycle(int cycleId) @@ -62,29 +83,29 @@ Data* SensorBMx280::read(bool shouldPostData) { if(!isResetting && bme != NULL) { - if(_calcType=="DIRECT_PERCENT") + if(_calculation->getValueType()=="humidity") { float humidity = bme->hum(); shouldPostData = smartSensorCheck(humidity, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, humidity, shouldPostData); + return _calculation->calculate(this, humidity, shouldPostData); } - else if(_calcType=="DIRECT_CELSIUS") - { + else if(_calculation->getValueType()=="temperature") + { float tempC = bme->temp(); shouldPostData = smartSensorCheck(tempC, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, tempC, shouldPostData); + return _calculation->calculate(this, tempC, shouldPostData); } - else if(_calcType=="DIRECT_HEKTOPASCAL") - { + else if(_calculation->getValueType()=="pressure") + { float pressure = bme->pres() / 100.0F; shouldPostData = smartSensorCheck(pressure, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, pressure, shouldPostData); + return _calculation->calculate(this, pressure, shouldPostData); } - else if(_calcType=="CALC_METER") - { + else if(_calculation->getValueType()=="altitude") + { float pressure = bme->pres() / 100.0F; shouldPostData = smartSensorCheck(pressure, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, pressure, shouldPostData); + return _calculation->calculate(this, pressure, shouldPostData); } } @@ -112,9 +133,4 @@ boolean SensorBMx280::smartSensorCheck(float currentRawValue, float threshhold, return shouldPostData; -} - -void SensorBMx280::postCycle(int cycleId) -{ - } \ No newline at end of file diff --git a/src/input/i2c/SensorBMx280.h b/src/input/i2c/SensorBMx280.h index fd056f8..310d3d4 100644 --- a/src/input/i2c/SensorBMx280.h +++ b/src/input/i2c/SensorBMx280.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -25,16 +26,16 @@ class SensorBMx280 : public Sensor { private: - static BME280I2C* bme; - String _calcType; + static BME280I2C* bme76; + static BME280I2C* bme77; + BME280I2C* bme; float lastPostedValue = NAN; protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: - SensorBMx280 (long, String, String, String, String, String, int, int, float, SensorCalculation*); + SensorBMx280 (long, String, String, String, String, int, int, float, SensorCalculation*); }; #endif \ No newline at end of file diff --git a/src/input/i2c/SensorMax44009.cpp b/src/input/i2c/SensorMax44009.cpp index 9b9f951..cb1fa4c 100644 --- a/src/input/i2c/SensorMax44009.cpp +++ b/src/input/i2c/SensorMax44009.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -22,7 +23,7 @@ extern int powerMode; MAX44009* SensorMax44009::max44009; -SensorMax44009::SensorMax44009 (long id, String shortName, String name, String PortSDA, String PortSCL, String calcType, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorMax44009::SensorMax44009 (long id, String category, String shortName, String name, String PortSDA, String PortSCL, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { int i=0; failedInit = false; @@ -41,9 +42,6 @@ SensorMax44009::SensorMax44009 (long id, String shortName, String name, String P i++; } - - _calcType = calcType; - } void SensorMax44009::preCycle(int cycleId) @@ -54,11 +52,11 @@ Data* SensorMax44009::read(bool shouldPostData) { if(!isResetting && !failedInit) { - if(_calcType=="DIRECT_LUX") + if(_calculation->getValueType()=="illuminance") { float illuminance = max44009->get_lux(); shouldPostData = smartSensorCheck(illuminance, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, illuminance, shouldPostData); + return _calculation->calculate(this, illuminance, shouldPostData); } } return NULL; @@ -85,9 +83,4 @@ boolean SensorMax44009::smartSensorCheck(float currentRawValue, float threshhold return shouldPostData; -} - -void SensorMax44009::postCycle(int cycleId) -{ - } \ No newline at end of file diff --git a/src/input/i2c/SensorMax44009.h b/src/input/i2c/SensorMax44009.h index 974a82d..7245296 100644 --- a/src/input/i2c/SensorMax44009.h +++ b/src/input/i2c/SensorMax44009.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -26,13 +27,11 @@ class SensorMax44009 : public Sensor { private: static MAX44009 *max44009; - String _calcType; boolean failedInit; float lastPostedValue = NAN; protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: SensorMax44009 (long, String, String, String, String, String, int, int, float, SensorCalculation*); diff --git a/src/input/onewire/SensorDHT.cpp b/src/input/onewire/SensorDHT.cpp index 5597699..2033e0d 100644 --- a/src/input/onewire/SensorDHT.cpp +++ b/src/input/onewire/SensorDHT.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v31 - Fixed an issue with DHT11 Sensors v29 - First Public Release */ @@ -57,7 +58,7 @@ DHT_Unified* SensorDHT::dht16 = NULL; extern boolean isResetting; extern int powerMode; -SensorDHT::SensorDHT (long id, String dhtType, String shortName, String name, uint8_t port, String calcType, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorDHT::SensorDHT (long id, String category, String shortName, String name, String dhtType, uint8_t port, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { uint8_t type; @@ -283,8 +284,6 @@ SensorDHT::SensorDHT (long id, String dhtType, String shortName, String name, ui } dht = dht16; } - - _calcType = calcType; } void SensorDHT::portFix(uint8_t port) @@ -304,32 +303,30 @@ Data* SensorDHT::read(bool shouldPostData) if(!isResetting) { sensors_event_t event; - - if(_calcType=="DIRECT_PERCENT") + + if(_calculation->getValueType()=="humidity") { - dht->humidity().getEvent(&event); + dht->humidity().getEvent(&event); if (isnan(event.relative_humidity)) { Serial.println("NAN Humidity!"); } else { shouldPostData = smartSensorCheck(event.relative_humidity, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, event.relative_humidity, shouldPostData); + return _calculation->calculate(this, event.relative_humidity, shouldPostData); } - } - else if(_calcType=="DIRECT_CELSIUS") - { - dht->temperature().getEvent(&event); + else if(_calculation->getValueType()=="temperature") + { + dht->temperature().getEvent(&event); if (isnan(event.temperature)) { Serial.println("NAN Temperature!"); } else { shouldPostData = smartSensorCheck(event.temperature, _smartValueThreshold, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, event.temperature, shouldPostData); + return _calculation->calculate(this, event.temperature, shouldPostData); } - } } @@ -359,9 +356,4 @@ boolean SensorDHT::smartSensorCheck(float currentRawValue, float threshhold, boo return shouldPostData; -} - -void SensorDHT::postCycle(int cycleId) -{ - } \ No newline at end of file diff --git a/src/input/onewire/SensorDHT.h b/src/input/onewire/SensorDHT.h index 5c80e6c..8e20241 100644 --- a/src/input/onewire/SensorDHT.h +++ b/src/input/onewire/SensorDHT.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -60,16 +61,14 @@ class SensorDHT : public Sensor { static DHT_Unified* dht15; static DHT_Unified* dht16; DHT_Unified* dht; - String _calcType; float lastPostedValue = NAN; static void portFix(uint8_t); protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: - SensorDHT (long, String, String,String, uint8_t, String, int, int, float, SensorCalculation*); + SensorDHT (long, String, String, String,String, uint8_t, int, int, float, SensorCalculation*); }; #endif \ No newline at end of file diff --git a/src/input/onewire/SensorDallas.cpp b/src/input/onewire/SensorDallas.cpp index 776bd55..4312da9 100644 --- a/src/input/onewire/SensorDallas.cpp +++ b/src/input/onewire/SensorDallas.cpp @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -72,7 +73,7 @@ DallasTemperature* SensorDallas::dallasTemperature16 = NULL; extern boolean isResetting; extern int powerMode; -SensorDallas::SensorDallas (long id, String shortName, String name, uint8_t port, int channel, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { +SensorDallas::SensorDallas (long id, String category, String shortName, String name, uint8_t port, int channel, int refreshInterval, int postDataInterval, float smartValueThreshold, SensorCalculation* calculation) : Sensor (id, category, shortName, name, refreshInterval, postDataInterval, smartValueThreshold, calculation) { _channel = channel; @@ -268,7 +269,7 @@ SensorDallas::SensorDallas (long id, String shortName, String name, uint8_t port if(_channelgetAddress(_address, channel); - + } void SensorDallas::preCycle(int cycleId) @@ -300,7 +301,7 @@ Data* SensorDallas::read(bool shouldPostData) if(tempC!=-127.00 && tempC!=85.00) { shouldPostData = smartSensorCheck(tempC, 0.3f, shouldPostData); - return _calculation->calculate(_id, _name, _shortName, tempC, shouldPostData); + return _calculation->calculate(this, tempC, shouldPostData); } } @@ -329,9 +330,4 @@ boolean SensorDallas::smartSensorCheck(float currentRawValue, float threshhold, return shouldPostData; -} - -void SensorDallas::postCycle(int cycleId) -{ - } \ No newline at end of file diff --git a/src/input/onewire/SensorDallas.h b/src/input/onewire/SensorDallas.h index 6136011..e397c1d 100644 --- a/src/input/onewire/SensorDallas.h +++ b/src/input/onewire/SensorDallas.h @@ -11,6 +11,7 @@ SOURCE: https://github.com/sensate-io/firmware-esp8266.git @section HISTORY + v32 - Added MQTT Support! v29 - First Public Release */ /**************************************************************************/ @@ -87,10 +88,9 @@ class SensorDallas : public Sensor { protected: Data* read(bool); void preCycle(int); - void postCycle(int); boolean smartSensorCheck(float, float, boolean); public: - SensorDallas (long, String, String, uint8_t, int, int, int, float, SensorCalculation*); + SensorDallas (long, String, String, String, uint8_t, int, int, int, float, SensorCalculation*); }; #endif \ No newline at end of file