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.

335 lines
12 KiB

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