Xose Pérez
7 years ago
8 changed files with 656 additions and 419 deletions
Split View
Diff Options
-
+16 -10code/espurna/config/general.h
-
+1 -0code/espurna/config/hardware.h
-
+16 -57code/espurna/power.h
-
+112 -338code/espurna/power.ino
-
+144 -0code/espurna/power_emon.ino
-
+179 -0code/espurna/power_hlw8012.ino
-
+188 -0code/espurna/power_v9261f.ino
-
+0 -14code/espurna/v9261f.ino
+ 16
- 10
code/espurna/config/general.h
View File
+ 1
- 0
code/espurna/config/hardware.h
View File
+ 16
- 57
code/espurna/power.h
View File
+ 112
- 338
code/espurna/power.ino
View File
+ 144
- 0
code/espurna/power_emon.ino
View File
| @ -0,0 +1,144 @@ | |||
| /* | |||
| POWER EMON MODULE | |||
| Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com> | |||
| */ | |||
| #if (POWER_PROVIDER & POWER_PROVIDER_EMON == POWER_PROVIDER_EMON) | |||
| // ----------------------------------------------------------------------------- | |||
| // MODULE GLOBALS AND CACHE | |||
| // ----------------------------------------------------------------------------- | |||
| #include <EmonLiteESP.h> | |||
| EmonLiteESP _emon; | |||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||
| #include "brzo_i2c.h" | |||
| // 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(0); | |||
| #endif // POWER_PROVIDER == POWER_PROVIDER_EMON_ANALOG | |||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||
| uint8_t buffer[2]; | |||
| brzo_i2c_start_transaction(POWER_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(); | |||
| unsigned int value; | |||
| value = (buffer[0] & 0x0F) << 8; | |||
| value |= buffer[1]; | |||
| return value; | |||
| #endif // POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||
| } | |||
| // ----------------------------------------------------------------------------- | |||
| double _powerCurrent() { | |||
| static unsigned long last = 0; | |||
| static double current = 0; | |||
| if (millis() - last > 1000) { | |||
| last = millis(); | |||
| current = _emon.getCurrent(POWER_SAMPLES); | |||
| current -= POWER_CURRENT_OFFSET; | |||
| if (current < 0) current = 0; | |||
| } | |||
| return current; | |||
| } | |||
| double _powerVoltage() { | |||
| return _power_voltage; | |||
| } | |||
| double _powerActivePower() { | |||
| return _powerApparentPower(); | |||
| } | |||
| double _powerApparentPower() { | |||
| return _powerCurrent() * _powerVoltage(); | |||
| } | |||
| double _powerReactivePower() { | |||
| return 0; | |||
| } | |||
| double _powerPowerFactor() { | |||
| return 1; | |||
| } | |||
| // ----------------------------------------------------------------------------- | |||
| // PUBLIC API | |||
| // ----------------------------------------------------------------------------- | |||
| void powerEnabledProvider() { | |||
| // Nothing to do | |||
| } | |||
| void powerConfigureProvider() { | |||
| _emon.setCurrentRatio(getSetting("powerRatioC", POWER_CURRENT_RATIO).toFloat()); | |||
| _power_voltage = getSetting("powerVoltage", POWER_VOLTAGE).toFloat(); | |||
| } | |||
| void powerSetupProvider() { | |||
| _emon.initCurrent(currentCallback, POWER_ADC_BITS, POWER_REFERENCE_VOLTAGE, POWER_CURRENT_RATIO); | |||
| #if POWER_PROVIDER == POWER_PROVIDER_EMON_ADC121 | |||
| uint8_t buffer[2]; | |||
| buffer[0] = ADC121_REG_CONFIG; | |||
| buffer[1] = 0x00; | |||
| brzo_i2c_start_transaction(POWER_I2C_ADDRESS, I2C_SCL_FREQUENCY); | |||
| brzo_i2c_write(buffer, 2, false); | |||
| brzo_i2c_end_transaction(); | |||
| #endif | |||
| powerConfigureProvider(); | |||
| _emon.warmup(); | |||
| } | |||
| void powerLoopProvider(bool before) { | |||
| if (before) { | |||
| static unsigned long last = 0; | |||
| if (millis() - last > POWER_READ_INTERVAL) { | |||
| last = millis(); | |||
| _power_newdata = true; | |||
| } | |||
| } | |||
| } | |||
| #endif // (POWER_PROVIDER & POWER_PROVIDER_EMON == POWER_PROVIDER_EMON) | |||
+ 179
- 0
code/espurna/power_hlw8012.ino
View File
| @ -0,0 +1,179 @@ | |||
| /* | |||
| 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 _hlwSetCalibration() { | |||
| double value; | |||
| value = getSetting("powerRatioP", 0).toFloat(); | |||
| if (value > 0) _hlw8012.setPowerMultiplier(value); | |||
| value = getSetting("powerRatioC", 0).toFloat(); | |||
| if (value > 0) _hlw8012.setCurrentMultiplier(value); | |||
| value = getSetting("powerRatioV", 0).toFloat(); | |||
| if (value > 0) _hlw8012.setVoltageMultiplier(value); | |||
| } | |||
| void _hlwGetCalibration() { | |||
| setSetting("powerRatioP", _hlw8012.getPowerMultiplier()); | |||
| setSetting("powerRatioC", _hlw8012.getCurrentMultiplier()); | |||
| setSetting("powerRatioV", _hlw8012.getVoltageMultiplier()); | |||
| saveSettings(); | |||
| } | |||
| void _hlwResetCalibration() { | |||
| _hlw8012.resetMultipliers(); | |||
| _hlwGetCalibration(); | |||
| } | |||
| void _hlwExpectedPower(unsigned int power) { | |||
| if (power > 0) { | |||
| _hlw8012.expectedActivePower(power); | |||
| _hlwGetCalibration(); | |||
| } | |||
| } | |||
| void _hlwExpectedCurrent(double current) { | |||
| if (current > 0) { | |||
| _hlw8012.expectedCurrent(current); | |||
| _hlwGetCalibration(); | |||
| } | |||
| } | |||
| void _hlwExpectedVoltage(unsigned int voltage) { | |||
| if (voltage > 0) { | |||
| _hlw8012.expectedVoltage(voltage); | |||
| _hlwGetCalibration(); | |||
| } | |||
| } | |||
| // ----------------------------------------------------------------------------- | |||
| double _powerCurrent() { | |||
| return _hlw8012.getCurrent(); | |||
| } | |||
| double _powerVoltage() { | |||
| return _hlw8012.getVoltage(); | |||
| } | |||
| double _powerActivePower() { | |||
| return _hlw8012.getActivePower(); | |||
| } | |||
| double _powerApparentPower() { | |||
| return _hlw8012.getApparentPower(); | |||
| } | |||
| double _powerReactivePower() { | |||
| double active = _powerActivePower(); | |||
| double apparent = _powerApparentPower(); | |||
| if (apparent > active) return sqrt(apparent * apparent - active * active); | |||
| return 0; | |||
| } | |||
| double _powerPowerFactor() { | |||
| double apparent = _powerApparentPower(); | |||
| if (apparent > 0) return _powerActivePower() / apparent; | |||
| return 1; | |||
| } | |||
| // ----------------------------------------------------------------------------- | |||
| // PUBLIC API | |||
| // ----------------------------------------------------------------------------- | |||
| void powerEnabledProvider() { | |||
| 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); | |||
| } | |||
| } | |||
| void powerConfigureProvider() { | |||
| _hlwSetCalibration(); | |||
| _hlwGetCalibration(); | |||
| } | |||
| 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); | |||
| powerConfigureProvider(); | |||
| _power_wifi_onconnect = WiFi.onStationModeGotIP([](WiFiEventStationModeGotIP ipInfo) { | |||
| powerEnabled(true); | |||
| }); | |||
| _power_wifi_ondisconnect = WiFi.onStationModeDisconnected([](WiFiEventStationModeDisconnected ipInfo) { | |||
| powerEnabled(false); | |||
| }); | |||
| } | |||
| void powerLoopProvider(bool before) { | |||
| if (before) { | |||
| static unsigned long last = 0; | |||
| if (millis() - last > POWER_READ_INTERVAL) { | |||
| last = millis(); | |||
| _power_newdata = true; | |||
| } | |||
| } else { | |||
| // Toggle between current and voltage monitoring | |||
| #if (HLW8012_USE_INTERRUPTS == 0) | |||
| _hlw8012.toggleMode(); | |||
| #endif // (HLW8012_USE_INTERRUPTS == 0) | |||
| } | |||
| } | |||
| #endif // POWER_PROVIDER == POWER_PROVIDER_HLW8012 | |||
+ 188
- 0
code/espurna/power_v9261f.ino
View File
| @ -0,0 +1,188 @@ | |||
| /* | |||
| 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; | |||
| 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 (checksumOK()) { | |||
| _v9261f_active = (double) ( | |||
| (_v9261f_data[3]) + | |||
| (_v9261f_data[4] << 8) + | |||
| (_v9261f_data[5] << 16) + | |||
| (_v9261f_data[6] << 24) | |||
| ) / V9261F_POWER_FACTOR; | |||
| _v9261f_reactive = (double) ( | |||
| (_v9261f_data[7]) + | |||
| (_v9261f_data[8] << 8) + | |||
| (_v9261f_data[9] << 16) + | |||
| (_v9261f_data[10] << 24) | |||
| ) / V9261F_RPOWER_FACTOR; | |||
| _v9261f_voltage = (double) ( | |||
| (_v9261f_data[11]) + | |||
| (_v9261f_data[12] << 8) + | |||
| (_v9261f_data[13] << 16) + | |||
| (_v9261f_data[14] << 24) | |||
| ) / V9261F_VOLTAGE_FACTOR; | |||
| _v9261f_current = (double) ( | |||
| (_v9261f_data[15]) + | |||
| (_v9261f_data[16] << 8) + | |||
| (_v9261f_data[17] << 16) + | |||
| (_v9261f_data[18] << 24) | |||
| ) / V9261F_CURRENT_FACTOR; | |||
| _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; | |||
| } | |||
| } | |||
| } | |||
| boolean checksumOK() { | |||
| 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]; | |||
| } | |||
| // ----------------------------------------------------------------------------- | |||
| 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; | |||
| } | |||
| // ----------------------------------------------------------------------------- | |||
| // PUBLIC API | |||
| // ----------------------------------------------------------------------------- | |||
| void powerEnabledProvider() { | |||
| // Nothing to do | |||
| } | |||
| void powerConfigureProvider() { | |||
| // Nothing to do | |||
| } | |||
| 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_EMON | |||