Xose Pérez
7 years ago
18 changed files with 3454 additions and 4555 deletions
Unified View
Diff Options
-
+0 -114code/espurna/config/general.h
-
+4 -8code/espurna/config/hardware.h
-
+20 -1code/espurna/config/sensors.h
-
BINcode/espurna/data/index.html.gz
-
+0 -423code/espurna/power.ino
-
+0 -207code/espurna/power_ech1560.ino
-
+0 -184code/espurna/power_emon.ino
-
+0 -170code/espurna/power_hlw8012.ino
-
+0 -234code/espurna/power_v9261f.ino
-
+78 -17code/espurna/sensor.ino
-
+10 -10code/espurna/sensors/BaseSensor.h
-
+1 -1code/espurna/sensors/ECH1560Sensor.h
-
+1 -1code/espurna/sensors/EventSensor.h
-
+258 -0code/espurna/sensors/HLW8012Sensor.h
-
+3063 -3048code/espurna/static/index.html.gz.h
-
+0 -44code/espurna/ws.ino
-
+0 -17code/html/custom.js
-
+19 -76code/html/index.html
+ 0
- 114
code/espurna/config/general.h
View File
+ 4
- 8
code/espurna/config/hardware.h
View File
+ 20
- 1
code/espurna/config/sensors.h
View File
BIN
code/espurna/data/index.html.gz
View File
+ 0
- 423
code/espurna/power.ino
View File
| @ -1,423 +0,0 @@ | |||||
| /* | |||||
| POWER MODULE | |||||
| Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com> | |||||
| */ | |||||
| #if POWER_PROVIDER != POWER_PROVIDER_NONE | |||||
| // ----------------------------------------------------------------------------- | |||||
| // MODULE GLOBALS AND CACHE | |||||
| // ----------------------------------------------------------------------------- | |||||
| #include "filters/MedianFilter.h" | |||||
| #include <Hash.h> | |||||
| #include <ArduinoJson.h> | |||||
| bool _power_enabled = false; | |||||
| bool _power_newdata = false; | |||||
| bool _power_realtime = API_REAL_TIME_VALUES; | |||||
| unsigned long _power_read_interval = POWER_READ_INTERVAL; | |||||
| unsigned long _power_report_interval = POWER_REPORT_INTERVAL; | |||||
| double _power_current = 0; | |||||
| double _power_voltage = 0; | |||||
| double _power_apparent = 0; | |||||
| double _power_energy = 0; | |||||
| MedianFilter _filter_current = MedianFilter(); | |||||
| #if POWER_HAS_ACTIVE | |||||
| double _power_active = 0; | |||||
| double _power_reactive = 0; | |||||
| double _power_factor = 0; | |||||
| MedianFilter _filter_voltage = MedianFilter(); | |||||
| MedianFilter _filter_active = MedianFilter(); | |||||
| MedianFilter _filter_apparent = MedianFilter(); | |||||
| #endif | |||||
| #if POWER_HAS_ENERGY | |||||
| double _power_last_energy = 0; | |||||
| #endif | |||||
| // ----------------------------------------------------------------------------- | |||||
| // PRIVATE METHODS | |||||
| // ----------------------------------------------------------------------------- | |||||
| #if WEB_SUPPORT | |||||
| void _powerWebSocketOnSend(JsonObject& root) { | |||||
| root["pwrVisible"] = 1; | |||||
| root["pwrCurrent"] = getCurrent(); | |||||
| root["pwrVoltage"] = getVoltage(); | |||||
| root["pwrApparent"] = getApparentPower(); | |||||
| root["pwrEnergy"] = getPowerEnergy(); | |||||
| root["pwrReadEvery"] = powerReadInterval(); | |||||
| root["pwrReportEvery"] = powerReportInterval(); | |||||
| #if POWER_HAS_ACTIVE | |||||
| root["pwrActive"] = getActivePower(); | |||||
| root["pwrReactive"] = getReactivePower(); | |||||
| root["pwrFactor"] = int(100 * getPowerFactor()); | |||||
| #endif | |||||
| #if (POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG) || (POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121) | |||||
| root["emonVisible"] = 1; | |||||
| #endif | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_HLW8012 | |||||
| root["hlwVisible"] = 1; | |||||
| #endif | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_V9261F | |||||
| root["v9261fVisible"] = 1; | |||||
| #endif | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_ECH1560 | |||||
| root["ech1560fVisible"] = 1; | |||||
| #endif | |||||
| } | |||||
| void _powerAPISetup() { | |||||
| apiRegister(MQTT_TOPIC_CURRENT, MQTT_TOPIC_CURRENT, [](char * buffer, size_t len) { | |||||
| dtostrf(_power_realtime ? _powerCurrent() : getCurrent(), 1-len, POWER_CURRENT_DECIMALS, buffer); | |||||
| }); | |||||
| apiRegister(MQTT_TOPIC_VOLTAGE, MQTT_TOPIC_VOLTAGE, [](char * buffer, size_t len) { | |||||
| snprintf_P(buffer, len, PSTR("%d"), (int) (_power_realtime ? _powerVoltage() : getVoltage())); | |||||
| }); | |||||
| apiRegister(MQTT_TOPIC_POWER_APPARENT, MQTT_TOPIC_POWER_APPARENT, [](char * buffer, size_t len) { | |||||
| snprintf_P(buffer, len, PSTR("%d"), (int) (_power_realtime ? _powerApparentPower() : getApparentPower())); | |||||
| }); | |||||
| #if POWER_HAS_ENERGY | |||||
| apiRegister(MQTT_TOPIC_ENERGY_TOTAL, MQTT_TOPIC_ENERGY_TOTAL, [](char * buffer, size_t len) { | |||||
| snprintf_P(buffer, len, PSTR("%lu"), (int) (_power_realtime ? _powerEnergy() : getPowerEnergy())); | |||||
| }); | |||||
| #endif | |||||
| #if POWER_HAS_ACTIVE | |||||
| apiRegister(MQTT_TOPIC_POWER_ACTIVE, MQTT_TOPIC_POWER_ACTIVE, [](char * buffer, size_t len) { | |||||
| snprintf_P(buffer, len, PSTR("%d"), (int) (_power_realtime ? _powerActivePower() : getActivePower())); | |||||
| }); | |||||
| apiRegister(MQTT_TOPIC_POWER_FACTOR, MQTT_TOPIC_POWER_FACTOR, [](char * buffer, size_t len) { | |||||
| snprintf_P(buffer, len, PSTR("%d"), (int) (100 * (_power_realtime ? _powerPowerFactor() : getPowerFactor()))); | |||||
| }); | |||||
| #endif | |||||
| } | |||||
| #endif // WEB_SUPPORT | |||||
| void _powerReset() { | |||||
| _filter_current.reset(); | |||||
| #if POWER_HAS_ACTIVE | |||||
| _filter_apparent.reset(); | |||||
| _filter_voltage.reset(); | |||||
| _filter_active.reset(); | |||||
| #endif | |||||
| } | |||||
| void _powerRead() { | |||||
| // Get instantaneous values from HAL | |||||
| double current = _powerCurrent(); | |||||
| double voltage = _powerVoltage(); | |||||
| double apparent = _powerApparentPower(); | |||||
| #if POWER_HAS_ACTIVE | |||||
| double active = _powerActivePower(); | |||||
| double reactive = (apparent > active) ? sqrt(apparent * apparent - active * active) : 0; | |||||
| double factor = (apparent > 0) ? active / apparent : 1; | |||||
| if (factor > 1) factor = 1; | |||||
| #endif | |||||
| #if POWER_HAS_ENERGY | |||||
| _power_energy = _powerEnergy(); // Due to its nature this value doesn't have to be filtered | |||||
| #endif | |||||
| // Filters | |||||
| _filter_current.add(current); | |||||
| #if POWER_HAS_ACTIVE | |||||
| _filter_apparent.add(apparent); | |||||
| _filter_voltage.add(voltage); | |||||
| _filter_active.add(active); | |||||
| #endif | |||||
| // Debug | |||||
| /* | |||||
| char current_buffer[10]; | |||||
| dtostrf(current, 1-sizeof(current_buffer), POWER_CURRENT_DECIMALS, current_buffer); | |||||
| DEBUG_MSG_P(PSTR("[POWER] Current: %sA\n"), current_buffer); | |||||
| DEBUG_MSG_P(PSTR("[POWER] Voltage: %dV\n"), (int) voltage); | |||||
| DEBUG_MSG_P(PSTR("[POWER] Apparent Power: %dW\n"), (int) apparent); | |||||
| DEBUG_MSG_P(PSTR("[POWER] Energy: %dJ\n"), (int) _power_energy); | |||||
| #if POWER_HAS_ACTIVE | |||||
| DEBUG_MSG_P(PSTR("[POWER] Active Power: %dW\n"), (int) active); | |||||
| DEBUG_MSG_P(PSTR("[POWER] Reactive Power: %dW\n"), (int) reactive); | |||||
| DEBUG_MSG_P(PSTR("[POWER] Power Factor: %d%%\n"), (int) (100 * factor)); | |||||
| #endif | |||||
| */ | |||||
| // Update websocket clients | |||||
| #if WEB_SUPPORT | |||||
| if (wsConnected()) { | |||||
| DynamicJsonBuffer jsonBuffer; | |||||
| JsonObject& root = jsonBuffer.createObject(); | |||||
| root["pwrVisible"] = 1; | |||||
| root["pwrCurrent"] = roundTo(current, POWER_CURRENT_DECIMALS); | |||||
| root["pwrVoltage"] = roundTo(voltage, POWER_VOLTAGE_DECIMALS); | |||||
| root["pwrApparent"] = roundTo(apparent, POWER_POWER_DECIMALS); | |||||
| root["pwrEnergy"] = roundTo(_power_energy, POWER_ENERGY_DECIMALS); | |||||
| #if POWER_HAS_ACTIVE | |||||
| root["pwrActive"] = roundTo(active, POWER_POWER_DECIMALS); | |||||
| root["pwrReactive"] = roundTo(reactive, POWER_POWER_DECIMALS); | |||||
| root["pwrFactor"] = int(100 * factor); | |||||
| #endif | |||||
| #if (POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG) || (POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121) | |||||
| root["emonVisible"] = 1; | |||||
| #endif | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_HLW8012 | |||||
| root["hlwVisible"] = 1; | |||||
| #endif | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_V9261F | |||||
| root["v9261fVisible"] = 1; | |||||
| #endif | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_ECH1560 | |||||
| root["ech1560Visible"] = 1; | |||||
| #endif | |||||
| String output; | |||||
| root.printTo(output); | |||||
| wsSend(output.c_str()); | |||||
| } | |||||
| #endif | |||||
| } | |||||
| void _powerReport() { | |||||
| // Get the fitered values | |||||
| #if POWER_HAS_ACTIVE | |||||
| double max_power = _filter_active.max(); | |||||
| _power_current = _filter_current.result(); | |||||
| _power_voltage = _filter_voltage.result(); | |||||
| _power_active = _filter_active.result(); | |||||
| _power_apparent = _filter_apparent.result(); | |||||
| if (_power_active > _power_apparent) _power_apparent = _power_active; | |||||
| _power_reactive = (_power_apparent > _power_active) ? sqrt(_power_apparent * _power_apparent - _power_active * _power_active) : 0; | |||||
| _power_factor = (_power_apparent > 0) ? _power_active / _power_apparent : 1; | |||||
| if (_power_factor > 1) _power_factor = 1; | |||||
| double power = _power_active; | |||||
| #else | |||||
| double max_power = _filter_current.max() * _power_voltage; | |||||
| _power_current = _filter_current.result(); | |||||
| _power_apparent = _power_current * _power_voltage; | |||||
| double power = _power_apparent; | |||||
| #endif | |||||
| #if POWER_HAS_ENERGY | |||||
| double energy_delta = _power_energy - _power_last_energy; | |||||
| _power_last_energy = _power_energy; | |||||
| #else | |||||
| double energy_delta = power * (_power_report_interval / 1000.); | |||||
| _power_energy += energy_delta; | |||||
| #endif | |||||
| char buf_current[10]; | |||||
| char buf_energy_delta[20]; | |||||
| char buf_energy_total[20]; | |||||
| dtostrf(_power_current, 1-sizeof(buf_current), POWER_CURRENT_DECIMALS, buf_current); | |||||
| dtostrf(energy_delta * POWER_ENERGY_FACTOR, 1-sizeof(buf_energy_delta), POWER_ENERGY_DECIMALS, buf_energy_delta); | |||||
| dtostrf(_power_energy * POWER_ENERGY_FACTOR, 1-sizeof(buf_energy_total), POWER_ENERGY_DECIMALS, buf_energy_total); | |||||
| #if MQTT_SUPPORT | |||||
| { | |||||
| mqttSend(MQTT_TOPIC_CURRENT, buf_current); | |||||
| mqttSend(MQTT_TOPIC_POWER_APPARENT, String((int) _power_apparent).c_str()); | |||||
| mqttSend(MQTT_TOPIC_MAX_POWER, String((int) max_power).c_str()); | |||||
| mqttSend(MQTT_TOPIC_ENERGY_DELTA, buf_energy_delta); | |||||
| mqttSend(MQTT_TOPIC_ENERGY_TOTAL, buf_energy_total); | |||||
| #if POWER_HAS_ACTIVE | |||||
| mqttSend(MQTT_TOPIC_POWER_ACTIVE, String((int) _power_active).c_str()); | |||||
| mqttSend(MQTT_TOPIC_POWER_REACTIVE, String((int) _power_reactive).c_str()); | |||||
| mqttSend(MQTT_TOPIC_VOLTAGE, String((int) _power_voltage).c_str()); | |||||
| mqttSend(MQTT_TOPIC_POWER_FACTOR, String((int) 100 * _power_factor).c_str()); | |||||
| #endif | |||||
| } | |||||
| #endif | |||||
| #if DOMOTICZ_SUPPORT | |||||
| if (domoticzEnabled()) { | |||||
| // Domoticz expects energy in kWh | |||||
| char buf_energy_kwh[10]; | |||||
| dtostrf(energy_delta * POWER_ENERGY_FACTOR_KWH, 1-sizeof(buf_energy_kwh), POWER_ENERGY_DECIMALS_KWH, buf_energy_kwh); | |||||
| char buffer[20]; | |||||
| snprintf_P(buffer, sizeof(buffer), PSTR("%d;%s"), (int) power, buf_energy_kwh); | |||||
| domoticzSend("dczPowIdx", 0, buffer); | |||||
| domoticzSend("dczCurrentIdx", 0, buf_current); | |||||
| domoticzSend("dczEnergyIdx", 0, buf_energy_kwh); | |||||
| #if POWER_HAS_ACTIVE | |||||
| snprintf_P(buffer, sizeof(buffer), PSTR("%d"), (int) _power_voltage); | |||||
| domoticzSend("dczVoltIdx", 0, buffer); | |||||
| #endif | |||||
| } | |||||
| #endif | |||||
| #if INFLUXDB_SUPPORT | |||||
| if (idbEnabled()) { | |||||
| idbSend(MQTT_TOPIC_CURRENT, buf_current); | |||||
| idbSend(MQTT_TOPIC_POWER_APPARENT, String((int) _power_apparent).c_str()); | |||||
| idbSend(MQTT_TOPIC_MAX_POWER, String((int) max_power).c_str()); | |||||
| idbSend(MQTT_TOPIC_ENERGY_DELTA, buf_energy_delta); | |||||
| idbSend(MQTT_TOPIC_ENERGY_TOTAL, buf_energy_total); | |||||
| #if POWER_HAS_ACTIVE | |||||
| idbSend(MQTT_TOPIC_POWER_ACTIVE, String((int) _power_active).c_str()); | |||||
| idbSend(MQTT_TOPIC_POWER_REACTIVE, String((int) _power_reactive).c_str()); | |||||
| idbSend(MQTT_TOPIC_VOLTAGE, String((int) _power_voltage).c_str()); | |||||
| idbSend(MQTT_TOPIC_POWER_FACTOR, String((int) 100 * _power_factor).c_str()); | |||||
| #endif | |||||
| } | |||||
| #endif | |||||
| _powerReset(); | |||||
| } | |||||
| void _powerConfigure() { | |||||
| _power_realtime = getSetting("apiRealTime", API_REAL_TIME_VALUES).toInt() == 1; | |||||
| _power_read_interval = atol(getSetting("pwrReadEvery", POWER_READ_INTERVAL).c_str()); | |||||
| _power_report_interval = atol(getSetting("pwrReportEvery", POWER_REPORT_INTERVAL).c_str()); | |||||
| if (_power_read_interval < POWER_MIN_READ_INTERVAL) { | |||||
| _power_read_interval = POWER_MIN_READ_INTERVAL; | |||||
| setSetting("pwrReadEvery", _power_read_interval); | |||||
| } | |||||
| if (_power_report_interval < _power_read_interval) { | |||||
| _power_report_interval = _power_read_interval; | |||||
| setSetting("pwrReportEvery", _power_report_interval); | |||||
| } | |||||
| _powerConfigureProvider(); | |||||
| } | |||||
| // ----------------------------------------------------------------------------- | |||||
| // MAGNITUDE API | |||||
| // ----------------------------------------------------------------------------- | |||||
| bool hasActivePower() { | |||||
| return POWER_HAS_ACTIVE; | |||||
| } | |||||
| double getCurrent() { | |||||
| return roundTo(_power_current, POWER_CURRENT_DECIMALS); | |||||
| } | |||||
| double getVoltage() { | |||||
| return roundTo(_power_voltage, POWER_VOLTAGE_DECIMALS); | |||||
| } | |||||
| double getApparentPower() { | |||||
| return roundTo(_power_apparent, POWER_POWER_DECIMALS); | |||||
| } | |||||
| double getPowerEnergy() { | |||||
| roundTo(_power_energy, POWER_ENERGY_DECIMALS); | |||||
| } | |||||
| #if POWER_HAS_ACTIVE | |||||
| double getActivePower() { | |||||
| return roundTo(_power_active, POWER_POWER_DECIMALS); | |||||
| } | |||||
| double getReactivePower() { | |||||
| return roundTo(_power_reactive, POWER_POWER_DECIMALS); | |||||
| } | |||||
| double getPowerFactor() { | |||||
| return roundTo(_power_factor, 2); | |||||
| } | |||||
| #endif | |||||
| // ----------------------------------------------------------------------------- | |||||
| // PUBLIC API | |||||
| // ----------------------------------------------------------------------------- | |||||
| unsigned long powerReadInterval() { | |||||
| return _power_read_interval; | |||||
| } | |||||
| unsigned long powerReportInterval() { | |||||
| return _power_report_interval; | |||||
| } | |||||
| bool powerEnabled() { | |||||
| return _power_enabled; | |||||
| } | |||||
| void powerEnabled(bool enabled) { | |||||
| if (enabled & !_power_enabled) _powerReset(); | |||||
| _power_enabled = enabled; | |||||
| _powerEnabledProvider(); | |||||
| } | |||||
| void powerCalibrate(unsigned char magnitude, double value) { | |||||
| _powerCalibrateProvider(magnitude, value); | |||||
| } | |||||
| void powerResetCalibration() { | |||||
| _powerResetCalibrationProvider(); | |||||
| } | |||||
| void powerSetup() { | |||||
| // backwards compatibility | |||||
| moveSetting("pwMainsVoltage", "pwrVoltage"); | |||||
| moveSetting("emonMains", "pwrVoltage"); | |||||
| moveSetting("emonVoltage", "pwrVoltage"); | |||||
| moveSetting("pwCurrentRatio", "pwrRatioC"); | |||||
| moveSetting("emonRatio", "pwrRatioC"); | |||||
| moveSetting("powPowerMult", "pwrRatioP"); | |||||
| moveSetting("powCurrentMult", "pwrRatioC"); | |||||
| moveSetting("powVoltageMult", "pwrRatioV"); | |||||
| moveSetting("powerVoltage", "pwrVoltage"); | |||||
| moveSetting("powerRatioC", "pwrRatioC"); | |||||
| moveSetting("powerRatioV", "pwrRatioV"); | |||||
| moveSetting("powerRatioP", "pwrRatioP"); | |||||
| _powerSetupProvider(); | |||||
| _powerConfigure(); | |||||
| // API | |||||
| #if WEB_SUPPORT | |||||
| wsOnSendRegister(_powerWebSocketOnSend); | |||||
| wsOnAfterParseRegister(_powerConfigure); | |||||
| _powerAPISetup(); | |||||
| #endif | |||||
| DEBUG_MSG_P(PSTR("[POWER] POWER_PROVIDER = %d\n"), POWER_PROVIDER); | |||||
| } | |||||
| void powerLoop() { | |||||
| _powerLoopProvider(true); | |||||
| if (_power_newdata) { | |||||
| _power_newdata = false; | |||||
| _powerRead(); | |||||
| } | |||||
| static unsigned long last = 0; | |||||
| if (millis() - last > _power_report_interval) { | |||||
| last = millis(); | |||||
| _powerReport(); | |||||
| } | |||||
| _powerLoopProvider(false); | |||||
| } | |||||
| #endif // POWER_PROVIDER != POWER_PROVIDER_NONE | |||||
+ 0
- 207
code/espurna/power_ech1560.ino
View File
| @ -1,207 +0,0 @@ | |||||
| /* | |||||
| POWER ECH1560 MODULE | |||||
| Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com> | |||||
| */ | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_ECH1560 | |||||
| // ----------------------------------------------------------------------------- | |||||
| // MODULE GLOBALS AND CACHE | |||||
| // ----------------------------------------------------------------------------- | |||||
| volatile long _ech1560_bits_count = 0; | |||||
| volatile long _ech1560_clk_count = 0; | |||||
| volatile bool _ech1560_dosync = false; | |||||
| volatile bool _ech1560_nextbit = true; | |||||
| double _ech1560_apparent = 0; | |||||
| double _ech1560_voltage = 0; | |||||
| double _ech1560_current = 0; | |||||
| // ----------------------------------------------------------------------------- | |||||
| // HAL | |||||
| // ----------------------------------------------------------------------------- | |||||
| void _ech1560_sync() { | |||||
| unsigned int byte1 = 0; | |||||
| unsigned int byte2 = 0; | |||||
| unsigned int byte3 = 0; | |||||
| _ech1560_bits_count = 0; | |||||
| while (_ech1560_bits_count < 40); // skip the uninteresting 5 first bytes | |||||
| _ech1560_bits_count = 0; | |||||
| while (_ech1560_bits_count < 24) { // loop through the next 3 Bytes (6-8) and save byte 6 and 7 in Ba and Bb | |||||
| if (_ech1560_nextbit) { | |||||
| if (_ech1560_bits_count < 9) { // first Byte/8 bits in Ba | |||||
| byte1 = byte1 << 1; | |||||
| if (digitalRead(ECH1560_MISO_PIN) == HIGH) byte1 |= 1; | |||||
| _ech1560_nextbit = false; | |||||
| } else if (_ech1560_bits_count < 17) { // bit 9-16 is byte 7, stor in Bb | |||||
| byte2 = byte2 << 1; | |||||
| if (digitalRead(ECH1560_MISO_PIN) == HIGH) byte2 |= 1; | |||||
| _ech1560_nextbit = false; | |||||
| } | |||||
| } | |||||
| } | |||||
| if (byte2 != 3) { // if bit Bb is not 3, we have reached the important part, U is allready in Ba and Bb and next 8 Bytes will give us the Power. | |||||
| // voltage = 2 * (Ba + Bb / 255) | |||||
| _ech1560_voltage = 2.0 * ((float) byte1 + (float) byte2 / 255.0); | |||||
| // power: | |||||
| _ech1560_bits_count = 0; | |||||
| while (_ech1560_bits_count < 40); // skip the uninteresting 5 first bytes | |||||
| _ech1560_bits_count = 0; | |||||
| byte1 = 0; | |||||
| byte2 = 0; | |||||
| byte3 = 0; | |||||
| while (_ech1560_bits_count < 24) { //store byte 6, 7 and 8 in Ba and Bb & Bc. | |||||
| if (_ech1560_nextbit) { | |||||
| if (_ech1560_bits_count < 9) { | |||||
| byte1 = byte1 << 1; | |||||
| if (digitalRead(ECH1560_MISO_PIN) == HIGH) byte1 |= 1; | |||||
| _ech1560_nextbit = false; | |||||
| } else if (_ech1560_bits_count < 17) { | |||||
| byte2 = byte2 << 1; | |||||
| if (digitalRead(ECH1560_MISO_PIN) == HIGH) byte2 |= 1; | |||||
| _ech1560_nextbit = false; | |||||
| } else { | |||||
| byte3 = byte3 << 1; | |||||
| if (digitalRead(ECH1560_MISO_PIN) == HIGH) byte3 |= 1; | |||||
| _ech1560_nextbit = false; | |||||
| } | |||||
| } | |||||
| } | |||||
| #if ECH1560_INVERTED | |||||
| byte1 = 255 - byte1; | |||||
| byte2 = 255 - byte2; | |||||
| byte3 = 255 - byte3; | |||||
| #endif | |||||
| // power = (Ba*255+Bb+Bc/255)/2 | |||||
| _ech1560_apparent = ( (float) byte1 * 255 + (float) byte2 + (float) byte3 / 255.0) / 2; | |||||
| _ech1560_current = _ech1560_apparent / _ech1560_voltage; | |||||
| _power_newdata = true; | |||||
| _ech1560_dosync = false; | |||||
| } | |||||
| // If Bb is not 3 or something else than 0, something is wrong! | |||||
| if (byte2 == 0) _ech1560_dosync = false; | |||||
| } | |||||
| void ICACHE_RAM_ATTR _ech1560_isr() { | |||||
| // if we are trying to find the sync-time (CLK goes high for 1-2ms) | |||||
| if (_ech1560_dosync == false) { | |||||
| _ech1560_clk_count = 0; | |||||
| // register how long the ClkHigh is high to evaluate if we are at the part wher clk goes high for 1-2 ms | |||||
| while (digitalRead(ECH1560_CLK_PIN) == HIGH) { | |||||
| _ech1560_clk_count += 1; | |||||
| delayMicroseconds(30); //can only use delayMicroseconds in an interrupt. | |||||
| } | |||||
| // if the Clk was high between 1 and 2 ms than, its a start of a SPI-transmission | |||||
| if (_ech1560_clk_count >= 33 && _ech1560_clk_count <= 67) { | |||||
| _ech1560_dosync = true; | |||||
| } | |||||
| // we are in sync and logging CLK-highs | |||||
| } else { | |||||
| // increment an integer to keep track of how many bits we have read. | |||||
| _ech1560_bits_count += 1; | |||||
| _ech1560_nextbit = true; | |||||
| } | |||||
| } | |||||
| // ----------------------------------------------------------------------------- | |||||
| // POWER API | |||||
| // ----------------------------------------------------------------------------- | |||||
| double _powerCurrent() { | |||||
| return _ech1560_current; | |||||
| } | |||||
| double _powerVoltage() { | |||||
| return _ech1560_voltage; | |||||
| } | |||||
| double _powerActivePower() { | |||||
| return 0; | |||||
| } | |||||
| double _powerApparentPower() { | |||||
| return _ech1560_apparent; | |||||
| } | |||||
| double _powerReactivePower() { | |||||
| return 0; | |||||
| } | |||||
| double _powerPowerFactor() { | |||||
| return 1; | |||||
| } | |||||
| void _powerEnabledProvider() { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerConfigureProvider() { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerCalibrateProvider(unsigned char magnitude, double value) { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerResetCalibrationProvider() { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerSetupProvider() { | |||||
| pinMode(ECH1560_CLK_PIN, INPUT); | |||||
| pinMode(ECH1560_MISO_PIN, INPUT); | |||||
| attachInterrupt(ECH1560_CLK_PIN, _ech1560_isr, RISING); | |||||
| } | |||||
| void _powerLoopProvider(bool before) { | |||||
| if (!before) { | |||||
| if (_ech1560_dosync) _ech1560_sync(); | |||||
| } | |||||
| } | |||||
| #endif // POWER_PROVIDER == POWER_PROVIDER_ECH1560 | |||||
+ 0
- 184
code/espurna/power_emon.ino
View File
| @ -1,184 +0,0 @@ | |||||
| /* | |||||
| POWER EMON MODULE | |||||
| Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com> | |||||
| */ | |||||
| #if (POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG) || (POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121) | |||||
| // ----------------------------------------------------------------------------- | |||||
| // MODULE GLOBALS AND CACHE | |||||
| // ----------------------------------------------------------------------------- | |||||
| #include <EmonLiteESP.h> | |||||
| EmonLiteESP _emon; | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||||
| #if I2C_USE_BRZO | |||||
| #include "brzo_i2c.h" | |||||
| #else | |||||
| #include "Wire.h" | |||||
| #endif | |||||
| // ADC121 Registers | |||||
| #define ADC121_REG_RESULT 0x00 | |||||
| #define ADC121_REG_ALERT 0x01 | |||||
| #define ADC121_REG_CONFIG 0x02 | |||||
| #define ADC121_REG_LIMITL 0x03 | |||||
| #define ADC121_REG_LIMITH 0x04 | |||||
| #define ADC121_REG_HYST 0x05 | |||||
| #define ADC121_REG_CONVL 0x06 | |||||
| #define ADC121_REG_CONVH 0x07 | |||||
| #endif // POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||||
| // ----------------------------------------------------------------------------- | |||||
| // HAL | |||||
| // ----------------------------------------------------------------------------- | |||||
| unsigned int currentCallback() { | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG | |||||
| return analogRead(A0); | |||||
| #endif // POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||||
| unsigned int value; | |||||
| #if I2C_USE_BRZO | |||||
| uint8_t buffer[2]; | |||||
| brzo_i2c_start_transaction(ADC121_I2C_ADDRESS, I2C_SCL_FREQUENCY); | |||||
| buffer[0] = ADC121_REG_RESULT; | |||||
| brzo_i2c_write(buffer, 1, false); | |||||
| brzo_i2c_read(buffer, 2, false); | |||||
| brzo_i2c_end_transaction(); | |||||
| value = (buffer[0] & 0x0F) << 8; | |||||
| value |= buffer[1]; | |||||
| #else | |||||
| Wire.beginTransmission(ADC121_I2C_ADDRESS); | |||||
| Wire.write(ADC121_REG_RESULT); | |||||
| Wire.endTransmission(); | |||||
| Wire.requestFrom(ADC121_I2C_ADDRESS, 2); | |||||
| value = (Wire.read() & 0x0F) << 8; | |||||
| value = value + Wire.read(); | |||||
| #endif | |||||
| return value; | |||||
| #endif // POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||||
| } | |||||
| // ----------------------------------------------------------------------------- | |||||
| // POWER API | |||||
| // ----------------------------------------------------------------------------- | |||||
| double _powerCurrent() { | |||||
| static unsigned long last = 0; | |||||
| static double current = 0; | |||||
| if (millis() - last > 1000) { | |||||
| last = millis(); | |||||
| current = _emon.getCurrent(EMON_SAMPLES); | |||||
| current -= EMON_CURRENT_OFFSET; | |||||
| if (current < 0) current = 0; | |||||
| } | |||||
| return current; | |||||
| } | |||||
| double _powerVoltage() { | |||||
| return _power_voltage; | |||||
| } | |||||
| double _powerActivePower() { | |||||
| return 0; | |||||
| } | |||||
| double _powerApparentPower() { | |||||
| return _powerCurrent() * _powerVoltage(); | |||||
| } | |||||
| double _powerReactivePower() { | |||||
| return 0; | |||||
| } | |||||
| double _powerPowerFactor() { | |||||
| return 1; | |||||
| } | |||||
| void _powerEnabledProvider() { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerCalibrateProvider(unsigned char magnitude, double value) { | |||||
| if (value <= 0) return; | |||||
| if (magnitude == POWER_MAGNITUDE_ACTIVE) { | |||||
| double power = _powerApparentPower(); | |||||
| double ratio = getSetting("pwrRatioC", EMON_CURRENT_RATIO).toFloat(); | |||||
| ratio = ratio * (value / power); | |||||
| _emon.setCurrentRatio(ratio); | |||||
| setSetting("pwrRatioC", ratio); | |||||
| saveSettings(); | |||||
| } | |||||
| if (magnitude == POWER_MAGNITUDE_VOLTAGE) { | |||||
| _power_voltage = value; | |||||
| setSetting("pwrVoltage", value); | |||||
| saveSettings(); | |||||
| } | |||||
| } | |||||
| void _powerResetCalibrationProvider() { | |||||
| delSetting("pwrRatioC"); | |||||
| _powerConfigureProvider(); | |||||
| saveSettings(); | |||||
| } | |||||
| void _powerConfigureProvider() { | |||||
| _emon.setCurrentRatio(getSetting("pwrRatioC", EMON_CURRENT_RATIO).toFloat()); | |||||
| _power_voltage = getSetting("pwrVoltage", POWER_VOLTAGE).toFloat(); | |||||
| } | |||||
| void _powerSetupProvider() { | |||||
| _emon.initCurrent(currentCallback, EMON_ADC_BITS, EMON_REFERENCE_VOLTAGE, EMON_CURRENT_RATIO); | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||||
| #if I2C_USE_BRZO | |||||
| uint8_t buffer[2]; | |||||
| buffer[0] = ADC121_REG_CONFIG; | |||||
| buffer[1] = 0x00; | |||||
| brzo_i2c_start_transaction(ADC121_I2C_ADDRESS, I2C_SCL_FREQUENCY); | |||||
| brzo_i2c_write(buffer, 2, false); | |||||
| brzo_i2c_end_transaction(); | |||||
| #else | |||||
| Wire.beginTransmission(ADC121_I2C_ADDRESS); | |||||
| Wire.write(ADC121_REG_CONFIG); | |||||
| Wire.write(0x00); | |||||
| Wire.endTransmission(); | |||||
| #endif | |||||
| #endif | |||||
| _emon.warmup(); | |||||
| } | |||||
| void _powerLoopProvider(bool before) { | |||||
| if (before) { | |||||
| static unsigned long last = 0; | |||||
| if (millis() - last > powerReadInterval()) { | |||||
| last = millis(); | |||||
| _power_newdata = true; | |||||
| } | |||||
| } | |||||
| } | |||||
| #endif // (POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG) || (POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121) | |||||
+ 0
- 170
code/espurna/power_hlw8012.ino
View File
| @ -1,170 +0,0 @@ | |||||
| /* | |||||
| POWER HLW8012 MODULE | |||||
| Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com> | |||||
| */ | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_HLW8012 | |||||
| // ----------------------------------------------------------------------------- | |||||
| // MODULE GLOBALS AND CACHE | |||||
| // ----------------------------------------------------------------------------- | |||||
| #include <HLW8012.h> | |||||
| #include <ESP8266WiFi.h> | |||||
| HLW8012 _hlw8012; | |||||
| WiFiEventHandler _power_wifi_onconnect; | |||||
| WiFiEventHandler _power_wifi_ondisconnect; | |||||
| // ----------------------------------------------------------------------------- | |||||
| // HAL | |||||
| // ----------------------------------------------------------------------------- | |||||
| void ICACHE_RAM_ATTR _hlw_cf1_isr() { | |||||
| _hlw8012.cf1_interrupt(); | |||||
| } | |||||
| void ICACHE_RAM_ATTR _hlw_cf_isr() { | |||||
| _hlw8012.cf_interrupt(); | |||||
| } | |||||
| void _hlwRestoreCalibration() { | |||||
| double value; | |||||
| value = getSetting("pwrRatioP", 0).toFloat(); | |||||
| if (value > 0) _hlw8012.setPowerMultiplier(value); | |||||
| value = getSetting("pwrRatioC", 0).toFloat(); | |||||
| if (value > 0) _hlw8012.setCurrentMultiplier(value); | |||||
| value = getSetting("pwrRatioV", 0).toFloat(); | |||||
| if (value > 0) _hlw8012.setVoltageMultiplier(value); | |||||
| } | |||||
| void _hlwPersistCalibration() { | |||||
| setSetting("pwrRatioP", _hlw8012.getPowerMultiplier()); | |||||
| setSetting("pwrRatioC", _hlw8012.getCurrentMultiplier()); | |||||
| setSetting("pwrRatioV", _hlw8012.getVoltageMultiplier()); | |||||
| saveSettings(); | |||||
| } | |||||
| // ----------------------------------------------------------------------------- | |||||
| // POWER API | |||||
| // ----------------------------------------------------------------------------- | |||||
| double _powerCurrent() { | |||||
| return _hlw8012.getCurrent(); | |||||
| } | |||||
| double _powerVoltage() { | |||||
| return _hlw8012.getVoltage(); | |||||
| } | |||||
| double _powerActivePower() { | |||||
| return _hlw8012.getActivePower(); | |||||
| } | |||||
| double _powerApparentPower() { | |||||
| return _hlw8012.getApparentPower(); | |||||
| } | |||||
| double _powerReactivePower() { | |||||
| return _hlw8012.getReactivePower(); | |||||
| } | |||||
| double _powerPowerFactor() { | |||||
| return _hlw8012.getPowerFactor(); | |||||
| } | |||||
| double _powerEnergy() { | |||||
| return _hlw8012.getEnergy(); | |||||
| } | |||||
| void _powerEnabledProvider() { | |||||
| #if HLW8012_USE_INTERRUPTS | |||||
| if (_power_enabled) { | |||||
| attachInterrupt(HLW8012_CF1_PIN, _hlw_cf1_isr, CHANGE); | |||||
| attachInterrupt(HLW8012_CF_PIN, _hlw_cf_isr, CHANGE); | |||||
| } else { | |||||
| detachInterrupt(HLW8012_CF1_PIN); | |||||
| detachInterrupt(HLW8012_CF_PIN); | |||||
| } | |||||
| #endif | |||||
| } | |||||
| void _powerCalibrateProvider(unsigned char magnitude, double value) { | |||||
| if (value <= 0) return; | |||||
| if (magnitude == POWER_MAGNITUDE_ACTIVE) _hlw8012.expectedActivePower(value); | |||||
| if (magnitude == POWER_MAGNITUDE_CURRENT) _hlw8012.expectedCurrent(value); | |||||
| if (magnitude == POWER_MAGNITUDE_VOLTAGE) _hlw8012.expectedVoltage(value); | |||||
| _hlwPersistCalibration(); | |||||
| } | |||||
| void _powerResetCalibrationProvider() { | |||||
| _hlw8012.resetMultipliers(); | |||||
| delSetting("pwrRatioC"); | |||||
| delSetting("pwrRatioV"); | |||||
| delSetting("pwrRatioP"); | |||||
| saveSettings(); | |||||
| } | |||||
| void _powerConfigureProvider() { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerSetupProvider() { | |||||
| // Initialize HLW8012 | |||||
| // void begin(unsigned char cf_pin, unsigned char cf1_pin, unsigned char sel_pin, unsigned char currentWhen = HIGH, bool use_interrupts = false, unsigned long pulse_timeout = PULSE_TIMEOUT); | |||||
| // * cf_pin, cf1_pin and sel_pin are GPIOs to the HLW8012 IC | |||||
| // * currentWhen is the value in sel_pin to select current sampling | |||||
| // * set use_interrupts to true to use interrupts to monitor pulse widths | |||||
| // * leave pulse_timeout to the default value, recommended when using interrupts | |||||
| #if HLW8012_USE_INTERRUPTS | |||||
| _hlw8012.begin(HLW8012_CF_PIN, HLW8012_CF1_PIN, HLW8012_SEL_PIN, HLW8012_SEL_CURRENT, true); | |||||
| #else | |||||
| _hlw8012.begin(HLW8012_CF_PIN, HLW8012_CF1_PIN, HLW8012_SEL_PIN, HLW8012_SEL_CURRENT, false, 1000000); | |||||
| #endif | |||||
| // These values are used to calculate current, voltage and power factors as per datasheet formula | |||||
| // These are the nominal values for the Sonoff POW resistors: | |||||
| // * The CURRENT_RESISTOR is the 1milliOhm copper-manganese resistor in series with the main line | |||||
| // * The VOLTAGE_RESISTOR_UPSTREAM are the 5 470kOhm resistors in the voltage divider that feeds the V2P pin in the HLW8012 | |||||
| // * The VOLTAGE_RESISTOR_DOWNSTREAM is the 1kOhm resistor in the voltage divider that feeds the V2P pin in the HLW8012 | |||||
| _hlw8012.setResistors(HLW8012_CURRENT_R, HLW8012_VOLTAGE_R_UP, HLW8012_VOLTAGE_R_DOWN); | |||||
| _hlwRestoreCalibration(); | |||||
| #if HLW8012_USE_INTERRUPTS | |||||
| powerEnabled(true); //Always keep measurement active to keep track of energy used | |||||
| #else | |||||
| _power_wifi_onconnect = WiFi.onStationModeGotIP([](WiFiEventStationModeGotIP ipInfo) { | |||||
| powerEnabled(true); | |||||
| }); | |||||
| _power_wifi_ondisconnect = WiFi.onStationModeDisconnected([](WiFiEventStationModeDisconnected ipInfo) { | |||||
| powerEnabled(false); | |||||
| }); | |||||
| #endif | |||||
| } | |||||
| void _powerLoopProvider(bool before) { | |||||
| if (before) { | |||||
| static unsigned long last = 0; | |||||
| if (millis() - last > powerReadInterval()) { | |||||
| last = millis(); | |||||
| _power_newdata = true; | |||||
| // Toggle between current and voltage monitoring | |||||
| #if (HLW8012_USE_INTERRUPTS == 0) | |||||
| _hlw8012.toggleMode(); | |||||
| #endif // (HLW8012_USE_INTERRUPTS == 0) | |||||
| } | |||||
| } | |||||
| } | |||||
| #endif // POWER_PROVIDER == POWER_PROVIDER_HLW8012 | |||||
+ 0
- 234
code/espurna/power_v9261f.ino
View File
| @ -1,234 +0,0 @@ | |||||
| /* | |||||
| POWER V9261F MODULE | |||||
| Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com> | |||||
| */ | |||||
| #if POWER_PROVIDER == POWER_PROVIDER_V9261F | |||||
| // ----------------------------------------------------------------------------- | |||||
| // MODULE GLOBALS AND CACHE | |||||
| // ----------------------------------------------------------------------------- | |||||
| #include <SoftwareSerial.h> | |||||
| SoftwareSerial * _v9261f_uart; | |||||
| double _v9261f_active = 0; | |||||
| double _v9261f_reactive = 0; | |||||
| double _v9261f_voltage = 0; | |||||
| double _v9261f_current = 0; | |||||
| double _v9261f_ratioP = V9261F_POWER_FACTOR; | |||||
| double _v9261f_ratioC = V9261F_CURRENT_FACTOR; | |||||
| double _v9261f_ratioV = V9261F_VOLTAGE_FACTOR; | |||||
| double _v9261f_ratioR = V9261F_RPOWER_FACTOR; | |||||
| unsigned char _v9261f_data[24]; | |||||
| // ----------------------------------------------------------------------------- | |||||
| // HAL | |||||
| // ----------------------------------------------------------------------------- | |||||
| void _v9261fRead() { | |||||
| static unsigned char state = 0; | |||||
| static unsigned long last = 0; | |||||
| static bool found = false; | |||||
| static unsigned char index = 0; | |||||
| if (state == 0) { | |||||
| while (_v9261f_uart->available()) { | |||||
| _v9261f_uart->flush(); | |||||
| found = true; | |||||
| last = millis(); | |||||
| } | |||||
| if (found && (millis() - last > V9261F_SYNC_INTERVAL)) { | |||||
| _v9261f_uart->flush(); | |||||
| index = 0; | |||||
| state = 1; | |||||
| } | |||||
| } else if (state == 1) { | |||||
| while (_v9261f_uart->available()) { | |||||
| _v9261f_uart->read(); | |||||
| if (index++ >= 7) { | |||||
| _v9261f_uart->flush(); | |||||
| index = 0; | |||||
| state = 2; | |||||
| } | |||||
| } | |||||
| } else if (state == 2) { | |||||
| while (_v9261f_uart->available()) { | |||||
| _v9261f_data[index] = _v9261f_uart->read(); | |||||
| if (index++ >= 19) { | |||||
| _v9261f_uart->flush(); | |||||
| last = millis(); | |||||
| state = 3; | |||||
| } | |||||
| } | |||||
| } else if (state == 3) { | |||||
| if (_v9261fChecksum()) { | |||||
| _v9261f_active = (double) ( | |||||
| (_v9261f_data[3]) + | |||||
| (_v9261f_data[4] << 8) + | |||||
| (_v9261f_data[5] << 16) + | |||||
| (_v9261f_data[6] << 24) | |||||
| ) / _v9261f_ratioP; | |||||
| _v9261f_reactive = (double) ( | |||||
| (_v9261f_data[7]) + | |||||
| (_v9261f_data[8] << 8) + | |||||
| (_v9261f_data[9] << 16) + | |||||
| (_v9261f_data[10] << 24) | |||||
| ) / _v9261f_ratioR; | |||||
| _v9261f_voltage = (double) ( | |||||
| (_v9261f_data[11]) + | |||||
| (_v9261f_data[12] << 8) + | |||||
| (_v9261f_data[13] << 16) + | |||||
| (_v9261f_data[14] << 24) | |||||
| ) / _v9261f_ratioV; | |||||
| _v9261f_current = (double) ( | |||||
| (_v9261f_data[15]) + | |||||
| (_v9261f_data[16] << 8) + | |||||
| (_v9261f_data[17] << 16) + | |||||
| (_v9261f_data[18] << 24) | |||||
| ) / _v9261f_ratioC; | |||||
| if (_v9261f_active < 0) _v9261f_active = 0; | |||||
| if (_v9261f_reactive < 0) _v9261f_reactive = 0; | |||||
| if (_v9261f_voltage < 0) _v9261f_voltage = 0; | |||||
| if (_v9261f_current < 0) _v9261f_current = 0; | |||||
| _power_newdata = true; | |||||
| } | |||||
| last = millis(); | |||||
| index = 0; | |||||
| state = 4; | |||||
| } else if (state == 4) { | |||||
| while (_v9261f_uart->available()) { | |||||
| _v9261f_uart->flush(); | |||||
| last = millis(); | |||||
| } | |||||
| if (millis() - last > V9261F_SYNC_INTERVAL) { | |||||
| state = 1; | |||||
| } | |||||
| } | |||||
| } | |||||
| bool _v9261fChecksum() { | |||||
| unsigned char checksum = 0; | |||||
| for (unsigned char i = 0; i < 19; i++) { | |||||
| checksum = checksum + _v9261f_data[i]; | |||||
| } | |||||
| checksum = ~checksum + 0x33; | |||||
| return checksum == _v9261f_data[19]; | |||||
| } | |||||
| // ----------------------------------------------------------------------------- | |||||
| // POWER API | |||||
| // ----------------------------------------------------------------------------- | |||||
| double _powerCurrent() { | |||||
| return _v9261f_current; | |||||
| } | |||||
| double _powerVoltage() { | |||||
| return _v9261f_voltage; | |||||
| } | |||||
| double _powerActivePower() { | |||||
| return _v9261f_active; | |||||
| } | |||||
| double _powerApparentPower() { | |||||
| return sqrt(_v9261f_reactive * _v9261f_reactive + _v9261f_active * _v9261f_active); | |||||
| } | |||||
| double _powerReactivePower() { | |||||
| return _v9261f_reactive; | |||||
| } | |||||
| double _powerPowerFactor() { | |||||
| double apparent = _powerApparentPower(); | |||||
| if (apparent > 0) return _powerActivePower() / apparent; | |||||
| return 1; | |||||
| } | |||||
| void _powerEnabledProvider() { | |||||
| // Nothing to do | |||||
| } | |||||
| void _powerConfigureProvider() { | |||||
| _v9261f_ratioP = getSetting("pwrRatioP", V9261F_POWER_FACTOR).toFloat(); | |||||
| _v9261f_ratioV = getSetting("pwrRatioV", V9261F_VOLTAGE_FACTOR).toFloat(); | |||||
| _v9261f_ratioC = getSetting("pwrRatioC", V9261F_CURRENT_FACTOR).toFloat(); | |||||
| _v9261f_ratioR = getSetting("pwrRatioR", V9261F_RPOWER_FACTOR).toFloat(); | |||||
| } | |||||
| void _powerCalibrateProvider(unsigned char magnitude, double value) { | |||||
| if (value <= 0) return; | |||||
| if (magnitude == POWER_MAGNITUDE_ACTIVE) { | |||||
| _v9261f_ratioP = _v9261f_ratioP * (_v9261f_active / value); | |||||
| setSetting("pwrRatioP", _v9261f_ratioP); | |||||
| } | |||||
| if (magnitude == POWER_MAGNITUDE_CURRENT) { | |||||
| _v9261f_ratioC = _v9261f_ratioC * (_v9261f_current / value); | |||||
| setSetting("pwrRatioC", _v9261f_ratioC); | |||||
| } | |||||
| if (magnitude == POWER_MAGNITUDE_VOLTAGE) { | |||||
| _v9261f_ratioV = _v9261f_ratioV * (_v9261f_voltage / value); | |||||
| setSetting("pwrRatioV", _v9261f_ratioV); | |||||
| } | |||||
| if (magnitude == POWER_MAGNITUDE_POWER_FACTOR) { | |||||
| if (value < 100) { | |||||
| double apparent = _v9261f_ratioP / (value / 100); | |||||
| value = sqrt(apparent * apparent - _v9261f_ratioP * _v9261f_ratioP); | |||||
| _v9261f_ratioR = _v9261f_ratioR * (_v9261f_reactive / value); | |||||
| setSetting("pwrRatioR", _v9261f_ratioR); | |||||
| } | |||||
| } | |||||
| saveSettings(); | |||||
| } | |||||
| void _powerResetCalibrationProvider() { | |||||
| delSetting("pwrRatioP"); | |||||
| delSetting("pwrRatioC"); | |||||
| delSetting("pwrRatioV"); | |||||
| delSetting("pwrRatioR"); | |||||
| _powerConfigureProvider(); | |||||
| saveSettings(); | |||||
| } | |||||
| void _powerSetupProvider() { | |||||
| _v9261f_uart = new SoftwareSerial(V9261F_PIN, SW_SERIAL_UNUSED_PIN, V9261F_PIN_INVERSE, 256); | |||||
| _v9261f_uart->begin(V9261F_BAUDRATE); | |||||
| } | |||||
| void _powerLoopProvider(bool before) { | |||||
| if (before) { | |||||
| _v9261fRead(); | |||||
| } | |||||
| } | |||||
| #endif // POWER_PROVIDER == POWER_PROVIDER_V9261F | |||||
+ 78
- 17
code/espurna/sensor.ino
View File
+ 10
- 10
code/espurna/sensors/BaseSensor.h
View File
+ 1
- 1
code/espurna/sensors/ECH1560Sensor.h
View File
+ 1
- 1
code/espurna/sensors/EventSensor.h
View File
+ 258
- 0
code/espurna/sensors/HLW8012Sensor.h
View File
| @ -0,0 +1,258 @@ | |||||
| // ----------------------------------------------------------------------------- | |||||
| // Event Counter Sensor | |||||
| // Copyright (C) 2017 by Xose Pérez <xose dot perez at gmail dot com> | |||||
| // ----------------------------------------------------------------------------- | |||||
| #pragma once | |||||
| #include "Arduino.h" | |||||
| #include "BaseSensor.h" | |||||
| #include <ESP8266WiFi.h> | |||||
| #include <HLW8012.h> | |||||
| class HLW8012Sensor : public BaseSensor { | |||||
| public: | |||||
| // --------------------------------------------------------------------- | |||||
| // Public | |||||
| // --------------------------------------------------------------------- | |||||
| HLW8012Sensor(): BaseSensor() { | |||||
| _count = 7; | |||||
| _sensor_id = SENSOR_HLW8012_ID; | |||||
| } | |||||
| ~HLW8012Sensor() { | |||||
| detach(_interrupt_cf); | |||||
| detach(_interrupt_cf1); | |||||
| } | |||||
| void expectedCurrent(double expected) { | |||||
| _hlw8012->expectedCurrent(expected); | |||||
| } | |||||
| void expectedVoltage(unsigned int expected) { | |||||
| _hlw8012->expectedVoltage(expected); | |||||
| } | |||||
| void expectedPower(unsigned int expected) { | |||||
| _hlw8012->expectedActivePower(expected); | |||||
| } | |||||
| void resetRatios() { | |||||
| _hlw8012->resetMultipliers(); | |||||
| } | |||||
| // --------------------------------------------------------------------- | |||||
| void setSEL(unsigned char sel) { | |||||
| if (_sel == sel) return; | |||||
| _sel = sel; | |||||
| _dirty = true; | |||||
| } | |||||
| void setCF(unsigned char cf) { | |||||
| if (_cf == cf) return; | |||||
| _cf = cf; | |||||
| _dirty = true; | |||||
| } | |||||
| void setCF1(unsigned char cf1) { | |||||
| if (_cf1 == cf1) return; | |||||
| _cf1 = cf1; | |||||
| _dirty = true; | |||||
| } | |||||
| void setSELCurrent(bool value) { | |||||
| _sel_current = value; | |||||
| } | |||||
| void setCurrentRatio(double value) { | |||||
| _hlw8012->setCurrentMultiplier(value); | |||||
| }; | |||||
| void setVoltageRatio(double value) { | |||||
| _hlw8012->setVoltageMultiplier(value); | |||||
| }; | |||||
| void setPowerRatio(double value) { | |||||
| _hlw8012->setPowerMultiplier(value); | |||||
| }; | |||||
| // --------------------------------------------------------------------- | |||||
| unsigned char getSEL() { | |||||
| return _sel; | |||||
| } | |||||
| unsigned char getCF() { | |||||
| return _cf; | |||||
| } | |||||
| unsigned char getCF1() { | |||||
| return _cf1; | |||||
| } | |||||
| unsigned char getSELCurrent() { | |||||
| return _sel_current; | |||||
| } | |||||
| double getCurrentRatio() { | |||||
| return _hlw8012->getCurrentMultiplier(); | |||||
| }; | |||||
| double getVoltageRatio() { | |||||
| return _hlw8012->getVoltageMultiplier(); | |||||
| }; | |||||
| double getPowerRatio() { | |||||
| return _hlw8012->getPowerMultiplier(); | |||||
| }; | |||||
| // --------------------------------------------------------------------- | |||||
| // Sensors API | |||||
| // --------------------------------------------------------------------- | |||||
| // Initialization method, must be idempotent | |||||
| // Defined outside the class body | |||||
| void begin() { | |||||
| if (_hlw8012) delete _hlw8012; | |||||
| _hlw8012 = new HLW8012(); | |||||
| // Initialize HLW8012 | |||||
| // void begin(unsigned char cf_pin, unsigned char cf1_pin, unsigned char sel_pin, unsigned char currentWhen = HIGH, bool use_interrupts = false, unsigned long pulse_timeout = PULSE_TIMEOUT); | |||||
| // * cf_pin, cf1_pin and sel_pin are GPIOs to the HLW8012 IC | |||||
| // * currentWhen is the value in sel_pin to select current sampling | |||||
| // * set use_interrupts to true to use interrupts to monitor pulse widths | |||||
| // * leave pulse_timeout to the default value, recommended when using interrupts | |||||
| #if HLW8012_USE_INTERRUPTS | |||||
| _hlw8012->begin(_cf, _cf1, _sel, _sel_current, true); | |||||
| #else | |||||
| _hlw8012->begin(_cf, _cf1, _sel, _sel_current, false, 1000000); | |||||
| #endif | |||||
| // These values are used to calculate current, voltage and power factors as per datasheet formula | |||||
| // These are the nominal values for the Sonoff POW resistors: | |||||
| // * The CURRENT_RESISTOR is the 1milliOhm copper-manganese resistor in series with the main line | |||||
| // * The VOLTAGE_RESISTOR_UPSTREAM are the 5 470kOhm resistors in the voltage divider that feeds the V2P pin in the HLW8012 | |||||
| // * The VOLTAGE_RESISTOR_DOWNSTREAM is the 1kOhm resistor in the voltage divider that feeds the V2P pin in the HLW8012 | |||||
| _hlw8012->setResistors(HLW8012_CURRENT_R, HLW8012_VOLTAGE_R_UP, HLW8012_VOLTAGE_R_DOWN); | |||||
| // Handle interrupts | |||||
| #if HLW8012_USE_INTERRUPTS | |||||
| _enable(true); | |||||
| #else | |||||
| _onconnect_handler = WiFi.onStationModeGotIP([this](WiFiEventStationModeGotIP ipInfo) { | |||||
| _enable(true); | |||||
| }); | |||||
| _ondisconnect_handler = WiFi.onStationModeDisconnected([this](WiFiEventStationModeDisconnected ipInfo) { | |||||
| _enable(false); | |||||
| }); | |||||
| #endif | |||||
| } | |||||
| // Descriptive name of the sensor | |||||
| String description() { | |||||
| char buffer[25]; | |||||
| snprintf(buffer, sizeof(buffer), "HLW8012 @ GPIO(%i,%i,%i)", _sel, _cf, _cf1); | |||||
| return String(buffer); | |||||
| } | |||||
| // Type for slot # index | |||||
| magnitude_t type(unsigned char index) { | |||||
| _error = SENSOR_ERROR_OK; | |||||
| if (index == 0) return MAGNITUDE_CURRENT; | |||||
| if (index == 1) return MAGNITUDE_VOLTAGE; | |||||
| if (index == 2) return MAGNITUDE_POWER_ACTIVE; | |||||
| if (index == 3) return MAGNITUDE_POWER_REACTIVE; | |||||
| if (index == 4) return MAGNITUDE_POWER_APPARENT; | |||||
| if (index == 5) return MAGNITUDE_POWER_FACTOR; | |||||
| if (index == 6) return MAGNITUDE_ENERGY; | |||||
| _error = SENSOR_ERROR_OUT_OF_RANGE; | |||||
| return MAGNITUDE_NONE; | |||||
| } | |||||
| // Current value for slot # index | |||||
| double value(unsigned char index) { | |||||
| _error = SENSOR_ERROR_OK; | |||||
| if (index == 0) return _hlw8012->getCurrent(); | |||||
| if (index == 1) return _hlw8012->getVoltage(); | |||||
| if (index == 2) return _hlw8012->getActivePower(); | |||||
| if (index == 3) return _hlw8012->getReactivePower(); | |||||
| if (index == 4) return _hlw8012->getApparentPower(); | |||||
| if (index == 5) return _hlw8012->getPowerFactor(); | |||||
| if (index == 6) return _hlw8012->getEnergy(); | |||||
| _error = SENSOR_ERROR_OUT_OF_RANGE; | |||||
| return 0; | |||||
| } | |||||
| // Post-read hook (usually to reset things) | |||||
| void post() { | |||||
| // Toggle between current and voltage monitoring | |||||
| #if (HLW8012_USE_INTERRUPTS == 0) | |||||
| _hlw8012->toggleMode(); | |||||
| #endif // (HLW8012_USE_INTERRUPTS == 0) | |||||
| } | |||||
| // Handle interrupt calls | |||||
| void ICACHE_RAM_ATTR handleInterrupt(unsigned char gpio) { | |||||
| if (gpio == _interrupt_cf) _hlw8012->cf_interrupt(); | |||||
| if (gpio == _interrupt_cf1) _hlw8012->cf1_interrupt(); | |||||
| } | |||||
| // Interrupt attach callback | |||||
| void attached(unsigned char gpio) { | |||||
| BaseSensor::attached(gpio); | |||||
| if (_cf == gpio) _interrupt_cf = gpio; | |||||
| if (_cf1 == gpio) _interrupt_cf1 = gpio; | |||||
| } | |||||
| // Interrupt detach callback | |||||
| void detached(unsigned char gpio) { | |||||
| BaseSensor::detached(gpio); | |||||
| if (_interrupt_cf == gpio) _interrupt_cf = GPIO_NONE; | |||||
| if (_interrupt_cf1 == gpio) _interrupt_cf1 = GPIO_NONE; | |||||
| } | |||||
| protected: | |||||
| // --------------------------------------------------------------------- | |||||
| // Protected | |||||
| // --------------------------------------------------------------------- | |||||
| void _enable(bool value) { | |||||
| if (value) { | |||||
| if (_interrupt_cf != _cf) { | |||||
| detach(_interrupt_cf); | |||||
| attach(this, _cf, CHANGE); | |||||
| } | |||||
| if (_interrupt_cf1 != _cf1) { | |||||
| detach(_interrupt_cf1); | |||||
| attach(this, _cf1, CHANGE); | |||||
| } | |||||
| } else { | |||||
| detach(_interrupt_cf); | |||||
| detach(_interrupt_cf1); | |||||
| } | |||||
| } | |||||
| // --------------------------------------------------------------------- | |||||
| unsigned char _sel; | |||||
| unsigned char _cf; | |||||
| unsigned char _cf1; | |||||
| bool _sel_current; | |||||
| HLW8012 * _hlw8012 = NULL; | |||||
| WiFiEventHandler _onconnect_handler; | |||||
| WiFiEventHandler _ondisconnect_handler; | |||||
| unsigned char _interrupt_cf = GPIO_NONE; | |||||
| unsigned char _interrupt_cf1 = GPIO_NONE; | |||||
| }; | |||||