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.

554 lines
16 KiB

  1. /*
  2. RELAY MODULE
  3. Copyright (C) 2016-2017 by Xose Pérez <xose dot perez at gmail dot com>
  4. */
  5. #include <EEPROM.h>
  6. #include <Ticker.h>
  7. #include <ArduinoJson.h>
  8. #include <vector>
  9. #include <functional>
  10. typedef struct {
  11. unsigned char pin;
  12. unsigned char type;
  13. unsigned char reset_pin;
  14. unsigned char led;
  15. unsigned long delay_on;
  16. unsigned long delay_off;
  17. unsigned int floodWindowStart;
  18. unsigned char floodWindowChanges;
  19. bool scheduled;
  20. unsigned int scheduledStatusTime;
  21. bool scheduledStatus;
  22. bool scheduledReport;
  23. Ticker pulseTicker;
  24. } relay_t;
  25. std::vector<relay_t> _relays;
  26. bool recursive = false;
  27. Ticker _relaySaveTicker;
  28. #if RELAY_PROVIDER == RELAY_PROVIDER_DUAL
  29. unsigned char _dual_status = 0;
  30. #endif
  31. // -----------------------------------------------------------------------------
  32. // RELAY PROVIDERS
  33. // -----------------------------------------------------------------------------
  34. void relayProviderStatus(unsigned char id, bool status) {
  35. if (id >= _relays.size()) return;
  36. #if RELAY_PROVIDER == RELAY_PROVIDER_RFBRIDGE
  37. rfbStatus(id, status);
  38. #endif
  39. #if RELAY_PROVIDER == RELAY_PROVIDER_DUAL
  40. _dual_status ^= (1 << id);
  41. Serial.flush();
  42. Serial.write(0xA0);
  43. Serial.write(0x04);
  44. Serial.write(_dual_status);
  45. Serial.write(0xA1);
  46. Serial.flush();
  47. #endif
  48. #if RELAY_PROVIDER == RELAY_PROVIDER_LIGHT
  49. lightState(status);
  50. lightUpdate(true, true);
  51. #endif
  52. #if RELAY_PROVIDER == RELAY_PROVIDER_RELAY
  53. if (_relays[id].type == RELAY_TYPE_NORMAL) {
  54. digitalWrite(_relays[id].pin, status);
  55. } else if (_relays[id].type == RELAY_TYPE_INVERSE) {
  56. digitalWrite(_relays[id].pin, !status);
  57. } else if (_relays[id].type == RELAY_TYPE_LATCHED) {
  58. digitalWrite(_relays[id].pin, LOW);
  59. digitalWrite(_relays[id].reset_pin, LOW);
  60. if (status) {
  61. digitalWrite(_relays[id].pin, HIGH);
  62. } else {
  63. digitalWrite(_relays[id].reset_pin, HIGH);
  64. }
  65. delay(RELAY_LATCHING_PULSE);
  66. digitalWrite(_relays[id].pin, LOW);
  67. digitalWrite(_relays[id].reset_pin, LOW);
  68. }
  69. #endif
  70. }
  71. bool relayProviderStatus(unsigned char id) {
  72. if (id >= _relays.size()) return false;
  73. #if RELAY_PROVIDER == RELAY_PROVIDER_RFBRIDGE
  74. return _relays[id].scheduledStatus;
  75. #endif
  76. #if RELAY_PROVIDER == RELAY_PROVIDER_DUAL
  77. return ((_dual_status & (1 << id)) > 0);
  78. #endif
  79. #if RELAY_PROVIDER == RELAY_PROVIDER_LIGHT
  80. return lightState();
  81. #endif
  82. #if RELAY_PROVIDER == RELAY_PROVIDER_RELAY
  83. if (_relays[id].type == RELAY_TYPE_NORMAL) {
  84. return (digitalRead(_relays[id].pin) == HIGH);
  85. } else if (_relays[id].type == RELAY_TYPE_INVERSE) {
  86. return (digitalRead(_relays[id].pin) == LOW);
  87. } else if (_relays[id].type == RELAY_TYPE_LATCHED) {
  88. return _relays[id].scheduledStatus;
  89. }
  90. #endif
  91. }
  92. // -----------------------------------------------------------------------------
  93. // RELAY
  94. // -----------------------------------------------------------------------------
  95. void relayPulse(unsigned char id) {
  96. byte relayPulseMode = getSetting("relayPulseMode", RELAY_PULSE_MODE).toInt();
  97. if (relayPulseMode == RELAY_PULSE_NONE) return;
  98. long relayPulseTime = 1000.0 * getSetting("relayPulseTime", RELAY_PULSE_TIME).toFloat();
  99. if (relayPulseTime == 0) return;
  100. bool status = relayStatus(id);
  101. bool pulseStatus = (relayPulseMode == RELAY_PULSE_ON);
  102. if (pulseStatus == status) {
  103. _relays[id].pulseTicker.detach();
  104. return;
  105. }
  106. _relays[id].pulseTicker.once_ms(relayPulseTime, relayToggle, id);
  107. }
  108. unsigned int relayPulseMode() {
  109. unsigned int value = getSetting("relayPulseMode", RELAY_PULSE_MODE).toInt();
  110. return value;
  111. }
  112. void relayPulseMode(unsigned int value, bool report) {
  113. setSetting("relayPulseMode", value);
  114. /*
  115. if (report) {
  116. char topic[strlen(MQTT_TOPIC_RELAY) + 10];
  117. snprintf_P(topic, sizeof(topic), PSTR("%s/pulse"), MQTT_TOPIC_RELAY);
  118. char value[2];
  119. snprintf_P(value, sizeof(value), PSTR("%d"), value);
  120. mqttSend(topic, value);
  121. }
  122. */
  123. #if WEB_SUPPORT
  124. char message[20];
  125. snprintf_P(message, sizeof(message), PSTR("{\"relayPulseMode\": %d}"), value);
  126. wsSend(message);
  127. #endif
  128. }
  129. void relayPulseMode(unsigned int value) {
  130. relayPulseMode(value, true);
  131. }
  132. void relayPulseToggle() {
  133. unsigned int value = relayPulseMode();
  134. value = (value == RELAY_PULSE_NONE) ? RELAY_PULSE_OFF : RELAY_PULSE_NONE;
  135. relayPulseMode(value);
  136. }
  137. bool relayStatus(unsigned char id, bool status, bool report) {
  138. if (id >= _relays.size()) return false;
  139. bool changed = false;
  140. #if TRACK_RELAY_STATUS
  141. if (relayStatus(id) == status) {
  142. if (_relays[id].scheduled) {
  143. DEBUG_MSG_P(PSTR("[RELAY] #%d scheduled change cancelled\n"), id);
  144. _relays[id].scheduled = false;
  145. _relays[id].scheduledStatus = status;
  146. _relays[id].scheduledReport = false;
  147. changed = true;
  148. }
  149. } else {
  150. #endif
  151. unsigned int currentTime = millis();
  152. unsigned int floodWindowEnd = _relays[id].floodWindowStart + 1000 * RELAY_FLOOD_WINDOW;
  153. unsigned long delay = status ? _relays[id].delay_on : _relays[id].delay_off;
  154. _relays[id].floodWindowChanges++;
  155. _relays[id].scheduledStatusTime = currentTime + delay;
  156. // If currentTime is off-limits the floodWindow...
  157. if (currentTime < _relays[id].floodWindowStart || floodWindowEnd <= currentTime) {
  158. // We reset the floodWindow
  159. _relays[id].floodWindowStart = currentTime;
  160. _relays[id].floodWindowChanges = 1;
  161. // If currentTime is in the floodWindow and there have been too many requests...
  162. } else if (_relays[id].floodWindowChanges >= RELAY_FLOOD_CHANGES) {
  163. // We schedule the changes to the end of the floodWindow
  164. // unless it's already delayed beyond that point
  165. if (floodWindowEnd - delay > currentTime) {
  166. _relays[id].scheduledStatusTime = floodWindowEnd;
  167. }
  168. }
  169. _relays[id].scheduled = true;
  170. _relays[id].scheduledStatus = status;
  171. if (report) _relays[id].scheduledReport = true;
  172. DEBUG_MSG_P(PSTR("[RELAY] #%d scheduled %s in %u ms\n"),
  173. id, status ? "ON" : "OFF",
  174. (_relays[id].scheduledStatusTime - currentTime));
  175. changed = true;
  176. #if TRACK_RELAY_STATUS
  177. }
  178. #endif
  179. return changed;
  180. }
  181. bool relayStatus(unsigned char id, bool status) {
  182. return relayStatus(id, status, true);
  183. }
  184. bool relayStatus(unsigned char id) {
  185. return relayProviderStatus(id);
  186. }
  187. void relaySync(unsigned char id) {
  188. if (_relays.size() > 1) {
  189. recursive = true;
  190. byte relaySync = getSetting("relaySync", RELAY_SYNC).toInt();
  191. bool status = relayStatus(id);
  192. // If RELAY_SYNC_SAME all relays should have the same state
  193. if (relaySync == RELAY_SYNC_SAME) {
  194. for (unsigned short i=0; i<_relays.size(); i++) {
  195. if (i != id) relayStatus(i, status);
  196. }
  197. // If NONE_OR_ONE or ONE and setting ON we should set OFF all the others
  198. } else if (status) {
  199. if (relaySync != RELAY_SYNC_ANY) {
  200. for (unsigned short i=0; i<_relays.size(); i++) {
  201. if (i != id) relayStatus(i, false);
  202. }
  203. }
  204. // If ONLY_ONE and setting OFF we should set ON the other one
  205. } else {
  206. if (relaySync == RELAY_SYNC_ONE) {
  207. unsigned char i = (id + 1) % _relays.size();
  208. relayStatus(i, true);
  209. }
  210. }
  211. recursive = false;
  212. }
  213. }
  214. void relaySave() {
  215. unsigned char bit = 1;
  216. unsigned char mask = 0;
  217. for (unsigned int i=0; i < _relays.size(); i++) {
  218. if (relayStatus(i)) mask += bit;
  219. bit += bit;
  220. }
  221. EEPROM.write(EEPROM_RELAY_STATUS, mask);
  222. DEBUG_MSG_P(PSTR("[RELAY] Saving mask: %d\n"), mask);
  223. EEPROM.commit();
  224. }
  225. void relayRetrieve(bool invert) {
  226. recursive = true;
  227. unsigned char bit = 1;
  228. unsigned char mask = invert ? ~EEPROM.read(EEPROM_RELAY_STATUS) : EEPROM.read(EEPROM_RELAY_STATUS);
  229. DEBUG_MSG_P(PSTR("[RELAY] Retrieving mask: %d\n"), mask);
  230. for (unsigned int id=0; id < _relays.size(); id++) {
  231. _relays[id].scheduled = true;
  232. _relays[id].scheduledStatus = ((mask & bit) == bit);
  233. _relays[id].scheduledReport = true;
  234. bit += bit;
  235. }
  236. if (invert) {
  237. EEPROM.write(EEPROM_RELAY_STATUS, mask);
  238. EEPROM.commit();
  239. }
  240. recursive = false;
  241. }
  242. void relayToggle(unsigned char id) {
  243. if (id >= _relays.size()) return;
  244. relayStatus(id, !relayStatus(id));
  245. }
  246. unsigned char relayCount() {
  247. return _relays.size();
  248. }
  249. //------------------------------------------------------------------------------
  250. // REST API
  251. //------------------------------------------------------------------------------
  252. #if WEB_SUPPORT
  253. void relaySetupAPI() {
  254. // API entry points (protected with apikey)
  255. for (unsigned int relayID=0; relayID<relayCount(); relayID++) {
  256. char url[15];
  257. snprintf_P(url, sizeof(url), PSTR("%s/%d"), MQTT_TOPIC_RELAY, relayID);
  258. char key[10];
  259. snprintf_P(key, sizeof(key), PSTR("%s%d"), MQTT_TOPIC_RELAY, relayID);
  260. apiRegister(url, key,
  261. [relayID](char * buffer, size_t len) {
  262. snprintf_P(buffer, len, PSTR("%d"), relayStatus(relayID) ? 1 : 0);
  263. },
  264. [relayID](const char * payload) {
  265. unsigned int value = payload[0] - '0';
  266. if (value == 2) {
  267. relayToggle(relayID);
  268. } else {
  269. relayStatus(relayID, value == 1);
  270. }
  271. }
  272. );
  273. }
  274. }
  275. #endif // WEB_SUPPORT
  276. //------------------------------------------------------------------------------
  277. // WebSockets
  278. //------------------------------------------------------------------------------
  279. #if WEB_SUPPORT
  280. void relayWS() {
  281. DynamicJsonBuffer jsonBuffer;
  282. JsonObject& root = jsonBuffer.createObject();
  283. JsonArray& relay = root.createNestedArray("relayStatus");
  284. for (unsigned char i=0; i<relayCount(); i++) {
  285. relay.add(relayStatus(i));
  286. }
  287. String output;
  288. root.printTo(output);
  289. wsSend(output.c_str());
  290. }
  291. #endif
  292. //------------------------------------------------------------------------------
  293. // MQTT
  294. //------------------------------------------------------------------------------
  295. void relayMQTT(unsigned char id) {
  296. if (id >= _relays.size()) return;
  297. mqttSend(MQTT_TOPIC_RELAY, id, relayStatus(id) ? "1" : "0");
  298. }
  299. void relayMQTT() {
  300. for (unsigned int i=0; i < _relays.size(); i++) {
  301. relayMQTT(i);
  302. }
  303. }
  304. void relayMQTTCallback(unsigned int type, const char * topic, const char * payload) {
  305. if (type == MQTT_CONNECT_EVENT) {
  306. #if not HEARTBEAT_REPORT_RELAY
  307. relayMQTT();
  308. #endif
  309. char buffer[strlen(MQTT_TOPIC_RELAY) + 3];
  310. snprintf_P(buffer, sizeof(buffer), PSTR("%s/+"), MQTT_TOPIC_RELAY);
  311. mqttSubscribe(buffer);
  312. }
  313. if (type == MQTT_MESSAGE_EVENT) {
  314. // Match topic
  315. String t = mqttSubtopic((char *) topic);
  316. if (!t.startsWith(MQTT_TOPIC_RELAY)) return;
  317. // Get value
  318. unsigned int value = (char)payload[0] - '0';
  319. // Pulse topic
  320. if (t.endsWith("pulse")) {
  321. relayPulseMode(value, mqttForward());
  322. return;
  323. }
  324. // Get relay ID
  325. unsigned int relayID = t.substring(strlen(MQTT_TOPIC_RELAY)+1).toInt();
  326. if (relayID >= relayCount()) {
  327. DEBUG_MSG_P(PSTR("[RELAY] Wrong relayID (%d)\n"), relayID);
  328. return;
  329. }
  330. // Action to perform
  331. if (value == 2) {
  332. relayToggle(relayID);
  333. } else {
  334. relayStatus(relayID, value > 0, mqttForward());
  335. }
  336. }
  337. }
  338. void relaySetupMQTT() {
  339. mqttRegister(relayMQTTCallback);
  340. }
  341. //------------------------------------------------------------------------------
  342. // InfluxDB
  343. //------------------------------------------------------------------------------
  344. #if INFLUXDB_SUPPORT
  345. void relayInfluxDB(unsigned char id) {
  346. if (id >= _relays.size()) return;
  347. char buffer[10];
  348. snprintf_P(buffer, sizeof(buffer), PSTR("%s,id=%d"), MQTT_TOPIC_RELAY, id);
  349. influxDBSend(buffer, relayStatus(id) ? "1" : "0");
  350. }
  351. #endif
  352. //------------------------------------------------------------------------------
  353. // Setup
  354. //------------------------------------------------------------------------------
  355. void relaySetup() {
  356. // Dummy relays for AI Light, Magic Home LED Controller, H801,
  357. // Sonoff Dual and Sonoff RF Bridge
  358. #ifdef DUMMY_RELAY_COUNT
  359. for (unsigned char i=0; i < DUMMY_RELAY_COUNT; i++) {
  360. _relays.push_back((relay_t) {0, RELAY_TYPE_NORMAL});
  361. _relays[i].scheduled = false;
  362. }
  363. #else
  364. #ifdef RELAY1_PIN
  365. _relays.push_back((relay_t) { RELAY1_PIN, RELAY1_TYPE, RELAY1_RESET_PIN, RELAY1_LED, RELAY1_DELAY_ON, RELAY1_DELAY_OFF });
  366. #endif
  367. #ifdef RELAY2_PIN
  368. _relays.push_back((relay_t) { RELAY2_PIN, RELAY2_TYPE, RELAY2_RESET_PIN, RELAY2_LED, RELAY2_DELAY_ON, RELAY2_DELAY_OFF });
  369. #endif
  370. #ifdef RELAY3_PIN
  371. _relays.push_back((relay_t) { RELAY3_PIN, RELAY3_TYPE, RELAY3_RESET_PIN, RELAY3_LED, RELAY3_DELAY_ON, RELAY3_DELAY_OFF });
  372. #endif
  373. #ifdef RELAY4_PIN
  374. _relays.push_back((relay_t) { RELAY4_PIN, RELAY4_TYPE, RELAY4_RESET_PIN, RELAY4_LED, RELAY4_DELAY_ON, RELAY4_DELAY_OFF });
  375. #endif
  376. #endif
  377. byte relayMode = getSetting("relayMode", RELAY_MODE).toInt();
  378. for (unsigned int i=0; i < _relays.size(); i++) {
  379. pinMode(_relays[i].pin, OUTPUT);
  380. if (relayMode == RELAY_MODE_OFF) relayStatus(i, false);
  381. if (relayMode == RELAY_MODE_ON) relayStatus(i, true);
  382. }
  383. if (relayMode == RELAY_MODE_SAME) relayRetrieve(false);
  384. if (relayMode == RELAY_MODE_TOOGLE) relayRetrieve(true);
  385. relayLoop();
  386. #if WEB_SUPPORT
  387. relaySetupAPI();
  388. #endif
  389. relaySetupMQTT();
  390. DEBUG_MSG_P(PSTR("[RELAY] Number of relays: %d\n"), _relays.size());
  391. }
  392. void relayLoop(void) {
  393. unsigned char id;
  394. for (id = 0; id < _relays.size(); id++) {
  395. unsigned int currentTime = millis();
  396. bool status = _relays[id].scheduledStatus;
  397. if (_relays[id].scheduled && currentTime >= _relays[id].scheduledStatusTime) {
  398. DEBUG_MSG_P(PSTR("[RELAY] #%d set to %s\n"), id, status ? "ON" : "OFF");
  399. // Call the provider to perform the action
  400. relayProviderStatus(id, status);
  401. // Change the binded LED if any
  402. if (_relays[id].led > 0) {
  403. ledStatus(_relays[id].led - 1, status);
  404. }
  405. // Send MQTT report if requested
  406. if (_relays[id].scheduledReport) {
  407. relayMQTT(id);
  408. }
  409. if (!recursive) {
  410. relayPulse(id);
  411. relaySync(id);
  412. _relaySaveTicker.once_ms(RELAY_SAVE_DELAY, relaySave);
  413. #if WEB_SUPPORT
  414. relayWS();
  415. #endif
  416. }
  417. #if DOMOTICZ_SUPPORT
  418. domoticzSendRelay(id);
  419. #endif
  420. #if INFLUXDB_SUPPORT
  421. relayInfluxDB(id);
  422. #endif
  423. _relays[id].scheduled = false;
  424. _relays[id].scheduledReport = false;
  425. }
  426. }
  427. }