Fork of the espurna firmware for `mhsw` switches
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

326 lines
11 KiB

6 years ago
  1. // -----------------------------------------------------------------------------
  2. // Event Counter Sensor
  3. // Copyright (C) 2017-2018 by Xose Pérez <xose dot perez at gmail dot com>
  4. // -----------------------------------------------------------------------------
  5. #if SENSOR_SUPPORT && HLW8012_SUPPORT
  6. #pragma once
  7. #include "Arduino.h"
  8. #include "BaseSensor.h"
  9. #include <ESP8266WiFi.h>
  10. #include <HLW8012.h>
  11. class HLW8012Sensor : public BaseSensor {
  12. public:
  13. // ---------------------------------------------------------------------
  14. // Public
  15. // ---------------------------------------------------------------------
  16. HLW8012Sensor(): BaseSensor() {
  17. _count = 7;
  18. _sensor_id = SENSOR_HLW8012_ID;
  19. _hlw8012 = new HLW8012();
  20. }
  21. ~HLW8012Sensor() {
  22. _enableInterrupts(false);
  23. delete _hlw8012;
  24. }
  25. void expectedCurrent(double expected) {
  26. _hlw8012->expectedCurrent(expected);
  27. }
  28. void expectedVoltage(unsigned int expected) {
  29. _hlw8012->expectedVoltage(expected);
  30. }
  31. void expectedPower(unsigned int expected) {
  32. _hlw8012->expectedActivePower(expected);
  33. }
  34. void resetRatios() {
  35. _hlw8012->resetMultipliers();
  36. }
  37. // ---------------------------------------------------------------------
  38. void setSEL(unsigned char sel) {
  39. if (_sel == sel) return;
  40. _sel = sel;
  41. _dirty = true;
  42. }
  43. void setCF(unsigned char cf) {
  44. if (_cf == cf) return;
  45. _cf = cf;
  46. _dirty = true;
  47. }
  48. void setCF1(unsigned char cf1) {
  49. if (_cf1 == cf1) return;
  50. _cf1 = cf1;
  51. _dirty = true;
  52. }
  53. void setSELCurrent(bool value) {
  54. _sel_current = value;
  55. }
  56. void setCurrentRatio(double value) {
  57. _hlw8012->setCurrentMultiplier(value);
  58. };
  59. void setVoltageRatio(double value) {
  60. _hlw8012->setVoltageMultiplier(value);
  61. };
  62. void setPowerRatio(double value) {
  63. _hlw8012->setPowerMultiplier(value);
  64. };
  65. // ---------------------------------------------------------------------
  66. unsigned char getSEL() {
  67. return _sel;
  68. }
  69. unsigned char getCF() {
  70. return _cf;
  71. }
  72. unsigned char getCF1() {
  73. return _cf1;
  74. }
  75. unsigned char getSELCurrent() {
  76. return _sel_current;
  77. }
  78. double getCurrentRatio() {
  79. return _hlw8012->getCurrentMultiplier();
  80. };
  81. double getVoltageRatio() {
  82. return _hlw8012->getVoltageMultiplier();
  83. };
  84. double getPowerRatio() {
  85. return _hlw8012->getPowerMultiplier();
  86. };
  87. // ---------------------------------------------------------------------
  88. // Sensors API
  89. // ---------------------------------------------------------------------
  90. // Initialization method, must be idempotent
  91. // Defined outside the class body
  92. void begin() {
  93. // Initialize HLW8012
  94. // 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);
  95. // * cf_pin, cf1_pin and sel_pin are GPIOs to the HLW8012 IC
  96. // * currentWhen is the value in sel_pin to select current sampling
  97. // * set use_interrupts to true to use interrupts to monitor pulse widths
  98. // * leave pulse_timeout to the default value, recommended when using interrupts
  99. #if HLW8012_USE_INTERRUPTS
  100. _hlw8012->begin(_cf, _cf1, _sel, _sel_current, true);
  101. #else
  102. _hlw8012->begin(_cf, _cf1, _sel, _sel_current, false, 1000000);
  103. #endif
  104. // These values are used to calculate current, voltage and power factors as per datasheet formula
  105. // These are the nominal values for the Sonoff POW resistors:
  106. // * The CURRENT_RESISTOR is the 1milliOhm copper-manganese resistor in series with the main line
  107. // * The VOLTAGE_RESISTOR_UPSTREAM are the 5 470kOhm resistors in the voltage divider that feeds the V2P pin in the HLW8012
  108. // * The VOLTAGE_RESISTOR_DOWNSTREAM is the 1kOhm resistor in the voltage divider that feeds the V2P pin in the HLW8012
  109. _hlw8012->setResistors(HLW8012_CURRENT_R, HLW8012_VOLTAGE_R_UP, HLW8012_VOLTAGE_R_DOWN);
  110. // Handle interrupts
  111. #if HLW8012_USE_INTERRUPTS
  112. _enableInterrupts(true);
  113. #else
  114. _onconnect_handler = WiFi.onStationModeGotIP([this](WiFiEventStationModeGotIP ipInfo) {
  115. _enableInterrupts(true);
  116. });
  117. _ondisconnect_handler = WiFi.onStationModeDisconnected([this](WiFiEventStationModeDisconnected ipInfo) {
  118. _enableInterrupts(false);
  119. });
  120. #endif
  121. }
  122. // Descriptive name of the sensor
  123. String description() {
  124. char buffer[25];
  125. snprintf(buffer, sizeof(buffer), "HLW8012 @ GPIO(%u,%u,%u)", _sel, _cf, _cf1);
  126. return String(buffer);
  127. }
  128. // Descriptive name of the slot # index
  129. String slot(unsigned char index) {
  130. return description();
  131. };
  132. // Address of the sensor (it could be the GPIO or I2C address)
  133. String address(unsigned char index) {
  134. char buffer[10];
  135. snprintf(buffer, sizeof(buffer), "%u:%u:%u", _sel, _cf, _cf1);
  136. return String(buffer);
  137. }
  138. // Type for slot # index
  139. unsigned char type(unsigned char index) {
  140. _error = SENSOR_ERROR_OK;
  141. if (index == 0) return MAGNITUDE_CURRENT;
  142. if (index == 1) return MAGNITUDE_VOLTAGE;
  143. if (index == 2) return MAGNITUDE_POWER_ACTIVE;
  144. if (index == 3) return MAGNITUDE_POWER_REACTIVE;
  145. if (index == 4) return MAGNITUDE_POWER_APPARENT;
  146. if (index == 5) return MAGNITUDE_POWER_FACTOR;
  147. if (index == 6) return MAGNITUDE_ENERGY;
  148. _error = SENSOR_ERROR_OUT_OF_RANGE;
  149. return MAGNITUDE_NONE;
  150. }
  151. // Current value for slot # index
  152. double value(unsigned char index) {
  153. _error = SENSOR_ERROR_OK;
  154. if (index == 0) return _hlw8012->getCurrent();
  155. if (index == 1) return _hlw8012->getVoltage();
  156. if (index == 2) return _hlw8012->getActivePower();
  157. if (index == 3) return _hlw8012->getReactivePower();
  158. if (index == 4) return _hlw8012->getApparentPower();
  159. if (index == 5) return 100 * _hlw8012->getPowerFactor();
  160. if (index == 6) return _hlw8012->getEnergy();
  161. _error = SENSOR_ERROR_OUT_OF_RANGE;
  162. return 0;
  163. }
  164. // Toggle between current and voltage monitoring
  165. #if HLW8012_USE_INTERRUPTS == 0
  166. // Post-read hook (usually to reset things)
  167. void post() { _hlw8012->toggleMode(); }
  168. #endif // HLW8012_USE_INTERRUPTS == 0
  169. // Handle interrupt calls
  170. void ICACHE_RAM_ATTR handleInterrupt(unsigned char gpio) {
  171. if (gpio == _cf) _hlw8012->cf_interrupt();
  172. if (gpio == _cf1) _hlw8012->cf1_interrupt();
  173. }
  174. protected:
  175. // ---------------------------------------------------------------------
  176. // Interrupt management
  177. // ---------------------------------------------------------------------
  178. void _attach(HLW8012Sensor * instance, unsigned char gpio, unsigned char mode);
  179. void _detach(unsigned char gpio);
  180. void _enableInterrupts(bool value) {
  181. static unsigned char _interrupt_cf = GPIO_NONE;
  182. static unsigned char _interrupt_cf1 = GPIO_NONE;
  183. if (value) {
  184. if (_interrupt_cf != _cf) {
  185. if (_interrupt_cf != GPIO_NONE) _detach(_interrupt_cf);
  186. _attach(this, _cf, CHANGE);
  187. _interrupt_cf = _cf;
  188. }
  189. if (_interrupt_cf1 != _cf1) {
  190. if (_interrupt_cf1 != GPIO_NONE) _detach(_interrupt_cf1);
  191. _attach(this, _cf1, CHANGE);
  192. _interrupt_cf1 = _cf1;
  193. }
  194. } else {
  195. _detach(_cf);
  196. _detach(_cf1);
  197. _interrupt_cf = GPIO_NONE;
  198. _interrupt_cf1 = GPIO_NONE;
  199. }
  200. }
  201. // ---------------------------------------------------------------------
  202. unsigned char _sel = GPIO_NONE;
  203. unsigned char _cf = GPIO_NONE;
  204. unsigned char _cf1 = GPIO_NONE;
  205. bool _sel_current = true;
  206. HLW8012 * _hlw8012 = NULL;
  207. #if HLW8012_USE_INTERRUPTS == 0
  208. WiFiEventHandler _onconnect_handler;
  209. WiFiEventHandler _ondisconnect_handler;
  210. #endif
  211. };
  212. // -----------------------------------------------------------------------------
  213. // Interrupt helpers
  214. // -----------------------------------------------------------------------------
  215. HLW8012Sensor * _hlw8012_sensor_instance[10] = {NULL};
  216. void ICACHE_RAM_ATTR _hlw8012_sensor_isr(unsigned char gpio) {
  217. unsigned char index = gpio > 5 ? gpio-6 : gpio;
  218. if (_hlw8012_sensor_instance[index]) {
  219. _hlw8012_sensor_instance[index]->handleInterrupt(gpio);
  220. }
  221. }
  222. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_0() { _hlw8012_sensor_isr(0); }
  223. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_1() { _hlw8012_sensor_isr(1); }
  224. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_2() { _hlw8012_sensor_isr(2); }
  225. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_3() { _hlw8012_sensor_isr(3); }
  226. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_4() { _hlw8012_sensor_isr(4); }
  227. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_5() { _hlw8012_sensor_isr(5); }
  228. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_12() { _hlw8012_sensor_isr(12); }
  229. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_13() { _hlw8012_sensor_isr(13); }
  230. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_14() { _hlw8012_sensor_isr(14); }
  231. void ICACHE_RAM_ATTR _hlw8012_sensor_isr_15() { _hlw8012_sensor_isr(15); }
  232. static void (*_hlw8012_sensor_isr_list[10])() = {
  233. _hlw8012_sensor_isr_0, _hlw8012_sensor_isr_1, _hlw8012_sensor_isr_2,
  234. _hlw8012_sensor_isr_3, _hlw8012_sensor_isr_4, _hlw8012_sensor_isr_5,
  235. _hlw8012_sensor_isr_12, _hlw8012_sensor_isr_13, _hlw8012_sensor_isr_14,
  236. _hlw8012_sensor_isr_15
  237. };
  238. void HLW8012Sensor::_attach(HLW8012Sensor * instance, unsigned char gpio, unsigned char mode) {
  239. if (!gpioValid(gpio)) return;
  240. _detach(gpio);
  241. unsigned char index = gpio > 5 ? gpio-6 : gpio;
  242. _hlw8012_sensor_instance[index] = instance;
  243. attachInterrupt(gpio, _hlw8012_sensor_isr_list[index], mode);
  244. #if SENSOR_DEBUG
  245. DEBUG_MSG_P(PSTR("[SENSOR] GPIO%u interrupt attached to %s\n"), gpio, instance->description().c_str());
  246. #endif
  247. }
  248. void HLW8012Sensor::_detach(unsigned char gpio) {
  249. if (!gpioValid(gpio)) return;
  250. unsigned char index = gpio > 5 ? gpio-6 : gpio;
  251. if (_hlw8012_sensor_instance[index]) {
  252. detachInterrupt(gpio);
  253. #if SENSOR_DEBUG
  254. DEBUG_MSG_P(PSTR("[SENSOR] GPIO%u interrupt detached from %s\n"), gpio, _hlw8012_sensor_instance[index]->description().c_str());
  255. #endif
  256. _hlw8012_sensor_instance[index] = NULL;
  257. }
  258. }
  259. #endif // SENSOR_SUPPORT && HLW8012_SUPPORT