From a34b9ba933c67ed31d67d10d03f49febf0bb7cc6 Mon Sep 17 00:00:00 2001 From: Ricky Brent Date: Fri, 20 Jan 2017 10:36:26 -0800 Subject: [PATCH 1/3] Added sending MQTT commands to a remote control attached to GPIO pins. --- FanRemoteGPIO.cpp | 278 ++++++++++++++++++++++ FanRemoteGPIO.h | 76 ++++++ README.md | 28 ++- _433toMQTTto433nFan_ESP8266.ino | 406 ++++++++++++++++++++++++++++++++ 4 files changed, 778 insertions(+), 10 deletions(-) create mode 100644 FanRemoteGPIO.cpp create mode 100644 FanRemoteGPIO.h create mode 100644 _433toMQTTto433nFan_ESP8266.ino diff --git a/FanRemoteGPIO.cpp b/FanRemoteGPIO.cpp new file mode 100644 index 0000000..c2a6f25 --- /dev/null +++ b/FanRemoteGPIO.cpp @@ -0,0 +1,278 @@ +/* + FanRemoteGPIO - Arduino libary to control a fan remote connected via GPIO pins. + Copyright (c) 2017 Ricky Brent + + Contributors: + - Ricky Brent + + Project home: https://github.com/rickybrent/fan-remote-gpio/ + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + ****************************************************/ + +#include "FanRemoteGPIO.h" + +FanRemoteGPIO::FanRemoteGPIO() { + this->lightPin = -1; + this->lightPinOff = -1; + this->fanPinFast = -1; + this->fanPinMedium = -1; + this->fanPinSlow = -1; + this->fanPinOff = -1; + this->nFanSpeed = 0; + this->nBrightness = 0; + this->nMaxBrightness = 3; + this->bLightOn = false; + this->bFanOn = false; + this->looping = false; + this->heldPin = -1; + this->heldUntil = 0; + this->queue = Queue(20); +} + +/** + * Enable a single light button and assign the pin. + * + * @param pin Arduino Pin to which the ligh button is connected to + */ +void FanRemoteGPIO::enableLight(int pin) { + this->lightPin = pin; + this->lightPinOff = -1; + initPin(this->lightPin); + // We want to have the light state in sync with what we think the state is. + // Oddly, the model tested will turn *off* with a 300-ms hold, but not on, + // which is exactly what we need(?): + // press(this->lightPin, 300); + // More testing shows the fan hates to be turned off then on again rapidly. +} + +/** + * Enable controlling the light, with separate pins for on and off. + * + * @param pinOn Arduino Pin to which the light on button is connected to + * @param pinOff Arduino Pin to which the light off button is connected to + */ +void FanRemoteGPIO::enableLight(int pinOn, int pinOff) { + this->lightPin = pinOn; + this->lightPinOff = pinOff; + initPin(this->lightPin); + initPin(this->lightPinOff); + // If we have an on and off button, we can guarentee the proper sync state: + this->turnLight(false); +} + +/** + * Disable controlling the light + */ +void FanRemoteGPIO::disableLight() { + this->lightPin = -1; + this->lightPinOff = -1; +} + +/** + * Enable controlling the fan speeds by separate pins per speed. + * + * @param pinFast Arduino Pin connected to the fast button + * @param pinMedium Arduino Pin connected to the medium button + * @param pinSlow Arduino Pin connected to the slow button + * @param pinOff Arduino Pin connected to the off button + */ +void FanRemoteGPIO::enableFanSpeeds(int pinFast, int pinMedium, int pinSlow, int pinOff) { + this->fanPinFast = pinFast; + this->fanPinMedium = pinMedium; + this->fanPinSlow = pinSlow; + this->fanPinOff = pinOff; + initPin(this->fanPinFast); + initPin(this->fanPinMedium); + initPin(this->fanPinSlow); + initPin(this->fanPinOff); + this->turnFan(false); // Easiest way to keep the real fan speed identical. +} + +/** + * Disable controlling the fan speeds + */ +void FanRemoteGPIO::disableFanSpeeds() { + this->fanPinFast = -1; + this->fanPinMedium = -1; + this->fanPinSlow = -1; + this->fanPinOff = -1; +} + + +/** + * Set the fan light brightness. + * Ideally, this should track the brightness level, then adjust it by timing + * how long the button is held down for. This is hard to get right. + */ +void FanRemoteGPIO::setBrightness(int level) { + if (level == 0) { + this->bLightOn = false; + if (this->lightPinOff < 0) { + press(this->lightPin); + } else { + press(this->lightPinOff); + } + } else if (level > 0) { + this->bLightOn = true; + // So much potential to mess up. + //int holdTime = 0; + if (this->nBrightness < this->nMaxBrightness) { + //seconds tested holding down: 1600, 1800, 2000, 2200, 2400 + //this->nBrightness + } + this->nBrightness = level; + press(this->lightPin); + } +} + + +/** + * Power the light back on without attempting to change its brightness level. + */ +void FanRemoteGPIO::turnLight(bool on) { + if (!on) { + Serial.println("Turned light off"); + setBrightness(0); + } else { + Serial.println("Turned light on"); + //setBrightness(this->nBrightness > 0 ? this->nBrightness : this->nMaxBrightness); + // Hack because I am having a lot of trouble with the light: + this->nBrightness = this->nMaxBrightness; + this->bLightOn = true; + press(this->lightPin, 200); + //press(this->lightPin, 2400); + //press(this->lightPin, 2400); + } +} + +/** + * Set the fan light brightness. + */ +void FanRemoteGPIO::setSpeed(int speed) { + if (speed == 0) { + this->bFanOn = false; + press(this->fanPinOff); + } else { + this->bFanOn = true; + this->nFanSpeed = speed; + if (speed == 1) { + press(this->fanPinSlow); + } else if (speed == 2) { + press(this->fanPinMedium); + } else if (speed == 3) { + press(this->fanPinFast); + } + } +} + +/** + * Power the fan back on to its last set speed. + */ +void FanRemoteGPIO::turnFan(bool on) { + if (!on) { + setSpeed(0); + } else { + setSpeed(this->nFanSpeed > 0 ? this->nFanSpeed : 3); + } +} + +/** + * Release any buttons being held down long enough. + */ +bool FanRemoteGPIO::available() { + this->looping = true; + if (this->heldPin >= 0 && this->heldUntil != 0 && this->heldUntil <= millis()) { + Serial.println("timed release!"); + digitalWrite(this->heldPin, HIGH); + this->heldPin = -1; + if ((queue.count()) > 0) { + QueuedPress queued = queue.pop(); + Serial.println("Queue in use"); + press(queued.pin, queued.time); + } + return true; + } + return false; +} + + +int FanRemoteGPIO::getBrightness() { + return ((this->bLightOn) ? this->nBrightness : 0); +} + +int FanRemoteGPIO::getSpeed() { + return ((this->bFanOn) ? this->nFanSpeed : 0); +} + +bool FanRemoteGPIO::isLightOn() { + return this->bLightOn; +} + +bool FanRemoteGPIO::isFanOn() { + return this->bFanOn; +} + +/** + * Set pin to output and HIGH. + */ +void FanRemoteGPIO::initPin(int pin) { + pinMode(pin, OUTPUT); + digitalWrite(pin, HIGH); +} + +/** + * Hold down the light button for the given ms. Useful for testing. + */ +void FanRemoteGPIO::holdLightButton(int time) { + press(this->lightPin, time); +} + + +/** + * Press a button. + */ +void FanRemoteGPIO::press(int pin) { + press(pin, 200); // Too long, and the light will begin adjusting brightness. +} + +/** + * Press a button, hold for the specified time, then release. + * @param pin Pin to press. + * @param time Delay before releasing, in milliseconds. + */ +void FanRemoteGPIO::press(int pin, int time) { + Serial.print("Pressed"); + Serial.println(pin); + if (pin < 0) + return; + if (this->heldPin > -1) { + struct QueuedPress queued; + queued.pin = pin; + queued.time = time; + this->queue.push(queued); + return; + } + digitalWrite(pin, LOW); + if (this->looping) { + this->heldPin = pin; + this->heldUntil = millis() + time; + } else { + if (time > 0) delay(time); + Serial.print("Released"); + Serial.println(pin); + digitalWrite(pin, HIGH); + } +} diff --git a/FanRemoteGPIO.h b/FanRemoteGPIO.h new file mode 100644 index 0000000..57c2cfe --- /dev/null +++ b/FanRemoteGPIO.h @@ -0,0 +1,76 @@ +/* + FanRemoteGPIO - Arduino libary to control a fan remote connected via GPIO pins. + Copyright (c) 2017 Ricky Brent + + Contributors: + - Ricky Brent + + Project home: https://github.com/rickybrent/fan-remote-gpio/ + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + ****************************************************/ + +#ifndef FanRemoteGPIO_h +#define FanRemoteGPIO_h + +#include +#include "Queue.h" +#include "Arduino.h" + +class FanRemoteGPIO +{ + public: + FanRemoteGPIO(); + void enableLight(int pin); + void enableLight(int pinOn, int pinOff); + void enableFanSpeeds(int pinFast, int pinMedium, int pinSlow, int pinOff); + void disableLight(); + void disableFanSpeeds(); + void turnLight(bool on); + void setBrightness(int brightness); + void turnFan(bool on); + void setSpeed(int speed); + void holdLightButton(int time); + int getBrightness(); + int getSpeed(); + bool isLightOn(); + bool isFanOn(); + bool available(); + private: + void initPin(int pin); + void press(int pin); + void press(int pin, int time); + int lightPin; + int lightPinOff; + int fanPinFast; + int fanPinMedium; + int fanPinSlow; + int fanPinOff; + int heldPin; + unsigned long heldUntil; + bool looping; + bool bLightOn; + bool bFanOn; + uint8_t nBrightness; + uint8_t nMaxBrightness; + uint8_t nFanSpeed; + struct QueuedPress { + int pin; + int time; + }; + Queue queue; +}; + +#endif diff --git a/README.md b/README.md index 5d6d62e..42409d1 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,28 @@ 433toMQTTto433 - ESP8266 program for home automation , gateway between 433mhz and MQTT on both directions Tutorial and schema are there https://1technophile.blogspot.com/2016/09/433tomqttto433-bidirectional-esp8266.html - + 433nIRtoMQTTto433nIR - ESP8266 gateway between 433mhz, infrared and MQTT on both directions Tutorial and schema are there https://1technophile.blogspot.fr/2016/11/433nIRtomqttto433nIR-bidirectional-esp8266.html - + +433toMQTTto433nFan_ESP8266 - ESP8266 gateway between 433mhz and a fan's remote control, from MQTT to the fan only. +Tutorial is here https://github.com/rickybrent/433toMQTTto433_ESP8266/wiki/Flower-Angel-18R-ST6 + These gateways can be integrated with home automation systems like Openhab or Home assistant thanks to the MQTT protocol. - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software -and associated documentation files (the "Software"), to deal in the Software without restriction, -including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, + +A list of supported 433mhz devices is available here: +https://community.home-assistant.io/t/433tomqttto433-gateway-device-list/7819 + +The gateway integrate Ntuple 433mhz signal detection over a determined time to avoid unnecessary MQTT messages. + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software +and associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/_433toMQTTto433nFan_ESP8266.ino b/_433toMQTTto433nFan_ESP8266.ino new file mode 100644 index 0000000..4c16e64 --- /dev/null +++ b/_433toMQTTto433nFan_ESP8266.ino @@ -0,0 +1,406 @@ +/* + 433nIRtoMQTTto433nIR - ESP8266 program for home automation + Tested OK on GeekCreek ESP12F + Fan remote control tested OK on Wemos D1 Mini + Not working on NodeMCU V0.9 + Act as a wifi gateway between your 433mhz/infrared IR signal and a MQTT broker + Send and receiving command by MQTT + + This program enables to: + - receive MQTT data from a topic and send RF 433Mhz signal corresponding to the received MQTT data + - publish MQTT data to a different topic related to received 433Mhz signal + - receive MQTT data from a topic and send IR signal corresponding to the received MQTT data + - publish MQTT data to a different topic related to received IR signal + + Contributors: + - 1technophile + - crankyoldgit + - rickybrent + Based on: + - MQTT library (https://github.com/knolleary) + - RCSwitch (https://github.com/sui77/rc-switch) + - ESP8266Wifi + - IRremoteESP8266 (https://github.com/markszabo/IRremoteESP8266) + + Project home: https://github.com/1technophile/433nIRtoMQTTto433nIR_ESP8266 + Blog, tutorial: http://1technophile.blogspot.com/2016/09/433nIRtomqttto433nIR-bidirectional-esp8266.html + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software +and associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Some usefull commands to test gateway with mosquitto: +Subscribe to the subject for data receiption from RF signal +mosquitto_sub -t home/433toMQTT +Send data by MQTT to convert it on RF signal +mosquitto_pub -t home/MQTTto433/ -m 1315153 +*/ +#include +#include +#include // library for controling Radio frequency switch +#include +#include // library for controlling a fan remote via GPIO pins +#include + +RCSwitch mySwitch = RCSwitch(); +FanRemoteGPIO fanRemote = FanRemoteGPIO(); + +//TODO: Disabled IR] IRrecv irrecv(D3); // Untested. Moved from 2. +//TODO: Disabled IR] IRsend irsend(D4); // Untested. Moved from 14. + +decode_results results; + +//Do we want to see trace for debugging purposes +#define TRACE 1 // 0= trace off 1 = trace on + +// Update these with values suitable for your network. +#define wifi_ssid "mywifiid" +#define wifi_password "mypwd" +#define mqtt_server "192.168.0.22" +#define mqtt_user "your_username" // not compulsory if you set it uncomment line 143 and comment line 145 +#define mqtt_password "your_password" // not compulsory if you set it uncomment line 143 and comment line 145 + +//variables to avoid duplicates for RF +#define time_avoid_duplicate 3000 // if you want to avoid duplicate mqtt message received set this to > 0, the value is the time in milliseconds during which we don't publish duplicates +// array to store previous received RFs codes and their timestamps +long ReceivedRF[10][2] ={{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}}; + +#define subjectMQTTtoX "home/commands/#" +//RF MQTT Subjects +#define subject433toMQTT "home/433toMQTT" +#define subjectMQTTto433 "home/commands/MQTTto433" +//IR MQTT Subjects +/*TODO: Disabled IR] +#define subjectIRtoMQTT "home/sensors/ir" +#define subjectMQTTtoIRCOOLIX "home/commands/sendCOOLIX" +#define subjectMQTTtoIRWhynter "home/commands/sendWhynter" +#define subjectMQTTtoIRNEC "home/commands/sendNEC" +#define subjectMQTTtoIRLG "home/commands/sendLG" +#define subjectMQTTtoIRSony "home/commands/sendSony" +#define subjectMQTTtoIRDISH "home/commands/sendDISH" +#define subjectMQTTtoIRSharp "home/commands/sendSharp" +#define subjectMQTTtoIRPanasonic "home/commands/sendPanasonic" +#define subjectMQTTtoIRSAMSUNG "home/commands/sendSAMSUNG" +TODO: Disabled IR] */ +//Fan MQTT Subjects +#define subjectMQTTtoFanSpeed "home/commands/MQTTtoFan/speed" // 0 to 3 +#define subjectMQTTtoFanBrightness "home/commands/MQTTtoFan/brightness" // 0 to 3 +#define subjectMQTTtoFanLight "home/commands/MQTTtoFan/light" // ON or OFF +#define subjectMQTTtoFan "home/commands/MQTTtoFan/fan" // ON or OFF +#define subjectMQTTtoFanHoldLight "home/commands/MQTTtoFan/holdLight" +#define subjectFanToMQTT "home/FanToMQTT" + +//adding this to bypass to problem of the arduino builder issue 50 +void callback(char*topic, byte* payload,unsigned int length); +WiFiClient espClient; + +// client parameters +PubSubClient client(mqtt_server, 1883, callback, espClient); + +//MQTT last attemps reconnection number +long lastReconnectAttempt = 0; + +// Callback function, when the gateway receive an MQTT value on the topics subscribed this function is called +void callback(char* topic, byte* payload, unsigned int length) { + // In order to republish this payload, a copy must be made + // as the orignal payload buffer will be overwritten whilst + // constructing the PUBLISH packet. + trc("Hey I got a callback "); + // Allocate the correct amount of memory for the payload copy + byte* p = (byte*)malloc(length + 1); + // Copy the payload to the new buffer + memcpy(p,payload,length); + + // Conversion to a printable string + p[length] = '\0'; + String callbackstring = String((char *) p); + String topicNameRec = String((char*) topic); + + //launch the function to treat received data + receivingMQTT(topicNameRec,callbackstring); + + // Free the memory + free(p); +} + +void setup() +{ + //Launch serial for debugging purposes + Serial.begin(9600); + + //Begining wifi connection + setup_wifi(); + delay(1500); + + lastReconnectAttempt = 0; + + //IR init parameters + //TODO: Disabled IR] irsend.begin(); + //TODO: Disabled IR] irrecv.enableIRIn(); // Start the receiver + + //RF init parameters + mySwitch.enableTransmit(D2); // RF Transmitter is connected to Pin D2 + mySwitch.setRepeatTransmit(20); //increase transmit repeat to avoid lost of rf sendings + mySwitch.enableReceive(D1); // Receiver on pin D1 + + //FanRemote init parameters. + fanRemote.enableFanSpeeds(D0, D5, D6, D7); + fanRemote.enableLight(D4); +} + +void setup_wifi() { + delay(10); + // We start by connecting to a WiFi network + trc("Connecting to "); + trc(wifi_ssid); + + WiFi.begin(wifi_ssid, wifi_password); + + while (WiFi.status() != WL_CONNECTED) { + delay(500); + trc("."); + } + trc("WiFi connected"); +} + +boolean reconnect() { + // Loop until we're reconnected + while (!client.connected()) { + trc("Attempting MQTT connection..."); + // Attempt to connect + // If you want to use a username and password, uncomment next line and comment the line if (client.connect("433toMQTTto433")) { + //if (client.connect("433nIRtoMQTTto433nIR", mqtt_user, mqtt_password)) { + // and set username and password at the program beginning + if (client.connect("433nIRtoMQTTto433nIR")) { + // Once connected, publish an announcement... + client.publish("outTopic","hello world"); + publishFanState(); + trc("connected"); + //Subscribing to topic(s) + subscribing(subjectMQTTtoX); + } else { + trc("failed, rc="); + trc(String(client.state())); + trc(" try again in 5 seconds"); + // Wait 5 seconds before retrying + delay(5000); + } + } + return client.connected(); +} + +void loop() +{ + //MQTT client connexion management + if (!client.connected()) { + long now = millis(); + if (now - lastReconnectAttempt > 5000) { + lastReconnectAttempt = now; + trc("client mqtt not connected, trying to connect"); + // Attempt to reconnect + if (reconnect()) { + lastReconnectAttempt = 0; + } + } + } else { + // MQTT loop + client.loop(); + } + + // Receive loop, if data received by RF433 send it by MQTT to subject433toMQTT + if (mySwitch.available()) { + // Topic on which we will send data + trc("Receiving 433Mhz signal"); + unsigned long MQTTvalue; + MQTTvalue=mySwitch.getReceivedValue(); + mySwitch.resetAvailable(); + if (client.connected()) { + if (!isAduplicate(MQTTvalue)) {// conditions to avoid duplications of RF -->MQTT + trc("Sending 433Mhz signal to MQTT"); + trc(String(MQTTvalue)); + sendMQTT(subject433toMQTT,String(MQTTvalue)); + storeValue(MQTTvalue); + } + } else { + if (reconnect()) { + trc("Sending 433Mhz signal to MQTT after reconnect"); + trc(String(MQTTvalue)); + sendMQTT(subject433toMQTT,String(MQTTvalue)); + storeValue(MQTTvalue); + lastReconnectAttempt = 0; + } + } + } + + // Receive loop, if data received by IR send it by MQTT to subjectIRtoMQTT + /*TODO: Disabled IR] + if (irrecv.decode(&results)) { + trc("Receiving IR signal"); + String MQTTvalue; + MQTTvalue=results.value; + trc("Sending IR signal to MQTT"); + trc(MQTTvalue); + sendMQTT(subjectIRtoMQTT,MQTTvalue); + irrecv.resume(); // Receive the next value + } + TODO: Disabled IR] */ + + // Receive loop, check for data from fan remote and release held buttons. + if (fanRemote.available()) { + publishFanState(); + } + + delay(100); + +} + +void storeValue(long MQTTvalue){ + long now = millis(); + // find oldest value of the buffer + int o = getMin(); + trc("Minimum index: " + String(o)); + // replace it by the new one + ReceivedRF[o][0] = MQTTvalue; + ReceivedRF[o][1] = now; + trc("send this code :" + String(ReceivedRF[o][0])+"/"+String(ReceivedRF[o][1])); + trc("Col: value/timestamp"); + for (int i = 0; i < 10; i++) + { + trc(String(i) + ":" + String(ReceivedRF[i][0])+"/"+String(ReceivedRF[i][1])); + } +} + +int getMin(){ + int minimum = ReceivedRF[0][1]; + int minindex=0; + for (int i = 0; i < 10; i++) + { + if (ReceivedRF[i][1] < minimum) { + minimum = ReceivedRF[i][1]; + minindex = i; + } + } + return minindex; +} + +boolean isAduplicate(long value){ +trc("isAduplicate"); +// check if the value has been already sent during the last "time_avoid_duplicate" +for (int i=0; i<10;i++){ + if (ReceivedRF[i][0] == value){ + long now = millis(); + if (now - ReceivedRF[i][1] < time_avoid_duplicate){ + trc("don't send this code :" + String(ReceivedRF[i][0])+"/"+String(ReceivedRF[i][1])); + return true; + } + } +} +return false; +} + +void subscribing(String topicNameRec){ // MQTT subscribing to topic + char topicStrRec[26]; + topicNameRec.toCharArray(topicStrRec,26); + // subscription to topic for receiving data + boolean pubresult = client.subscribe(topicStrRec); + if (pubresult) { + trc("subscription OK to"); + trc(topicNameRec); + } +} + +void receivingMQTT(String topicNameRec, String callbackstring) { + trc("Receiving data by MQTT"); + trc(topicNameRec); + char topicOri[26] = ""; + char topicStrAck[26] = ""; + char datacallback[32] = ""; + // Acknowledgement inside a subtopic to avoid loop + topicNameRec.toCharArray(topicOri,26); + char DataAck[26] = "OK"; + client.publish("home/ack", DataAck); + callbackstring.toCharArray(datacallback,32); + trc(datacallback); + unsigned long data = strtoul(datacallback, NULL, 10); // we will not be able to pass value > 4294967295 + trc(String(data)); + + if (topicNameRec == subjectMQTTto433){ + trc("Send received data by RF 433"); + //send received MQTT value by RF signal (example of signal sent data = 5264660) + mySwitch.send(data, 24); + } + /*TODO: Disabled IR] + //send received MQTT value by IR signal (example of signal sent data = 1086296175) + if (topicNameRec == subjectMQTTtoIRCOOLIX) + irsend.sendCOOLIX(data, 24); + if (topicNameRec == subjectMQTTtoIRWhynter) + irsend.sendWhynter(data, 32); + if (topicNameRec == subjectMQTTtoIRNEC) + irsend.sendNEC(data, 32); + if (topicNameRec == subjectMQTTtoIRLG) + irsend.sendLG(data, 28); + if (topicNameRec == subjectMQTTtoIRSony) + irsend.sendSony(data, 12); + if (topicNameRec == subjectMQTTtoIRDISH) + irsend.sendDISH(data, 16); + if (topicNameRec == subjectMQTTtoIRSharp) + irsend.sendSharpRaw(data, 15); + Panasonic has a two arguments per call. An address(16bit) and data(32bit), not data and nr_bits. + if (topicNameRec == subjectMQTTtoIRPanasonic) + irsend.sendPanasonic(data, 36); + if (topicNameRec == subjectMQTTtoIRSAMSUNG) + irsend.sendSAMSUNG(data, 32); + TODO: Disabled IR] */ + //control attached fan remote control based on recieved MQTT values + if (topicNameRec == subjectMQTTtoFanBrightness) + fanRemote.setBrightness(data); + if (topicNameRec == subjectMQTTtoFanLight) + fanRemote.turnLight(((callbackstring == "ON") || data > 0) ? true : false); + if (topicNameRec == subjectMQTTtoFan) + fanRemote.turnFan(((callbackstring == "ON") || data > 0) ? true : false); + if (topicNameRec == subjectMQTTtoFanSpeed) + fanRemote.setSpeed(data); + if (topicNameRec == subjectMQTTtoFanHoldLight) + fanRemote.holdLightButton(data); + +} + +//send MQTT data dataStr to topic topicNameSend +void sendMQTT(String topicNameSend, String dataStr){ + + char topicStrSend[26]; + topicNameSend.toCharArray(topicStrSend,26); + char dataStrSend[200]; + dataStr.toCharArray(dataStrSend,200); + boolean pubresult = client.publish(topicStrSend,dataStrSend); + trc("sending "); + trc(dataStr); + trc("to "); + trc(topicNameSend); + +} + +// function called to publish the state of the fan +void publishFanState() { + String json = String("{\"brightness\":") + fanRemote.getBrightness() + "," + " \"speed\":" + fanRemote.getSpeed() + "," + " \"light\":\"" + (fanRemote.isLightOn() ? "ON" : "OFF") + "\"," + " \"fan\":\"" + (fanRemote.isFanOn() ? "ON" : "OFF") + "\"" + "}"; + const char * msg = json.c_str(); + client.publish(subjectFanToMQTT, msg, true); +} + +//trace +void trc(String msg){ + if (TRACE) { + Serial.println(msg); + } +} From 5e8fca9ffc14d48b6d72db023988e2bd0c7ce747 Mon Sep 17 00:00:00 2001 From: Ricky Brent Date: Fri, 20 Jan 2017 10:48:47 -0800 Subject: [PATCH 2/3] Removed Serial.print lines and code cleanup. --- FanRemoteGPIO.cpp | 25 ++----------------------- 1 file changed, 2 insertions(+), 23 deletions(-) diff --git a/FanRemoteGPIO.cpp b/FanRemoteGPIO.cpp index c2a6f25..142959f 100644 --- a/FanRemoteGPIO.cpp +++ b/FanRemoteGPIO.cpp @@ -51,11 +51,6 @@ void FanRemoteGPIO::enableLight(int pin) { this->lightPin = pin; this->lightPinOff = -1; initPin(this->lightPin); - // We want to have the light state in sync with what we think the state is. - // Oddly, the model tested will turn *off* with a 300-ms hold, but not on, - // which is exactly what we need(?): - // press(this->lightPin, 300); - // More testing shows the fan hates to be turned off then on again rapidly. } /** @@ -127,12 +122,8 @@ void FanRemoteGPIO::setBrightness(int level) { } } else if (level > 0) { this->bLightOn = true; - // So much potential to mess up. - //int holdTime = 0; - if (this->nBrightness < this->nMaxBrightness) { - //seconds tested holding down: 1600, 1800, 2000, 2200, 2400 - //this->nBrightness - } + // Visible changes at: 1600, 1800, 2000, 2200, 2400. Difficult to time + // correctly matched with a level, and I rarely want the lights dimmed. this->nBrightness = level; press(this->lightPin); } @@ -144,17 +135,11 @@ void FanRemoteGPIO::setBrightness(int level) { */ void FanRemoteGPIO::turnLight(bool on) { if (!on) { - Serial.println("Turned light off"); setBrightness(0); } else { - Serial.println("Turned light on"); - //setBrightness(this->nBrightness > 0 ? this->nBrightness : this->nMaxBrightness); - // Hack because I am having a lot of trouble with the light: this->nBrightness = this->nMaxBrightness; this->bLightOn = true; press(this->lightPin, 200); - //press(this->lightPin, 2400); - //press(this->lightPin, 2400); } } @@ -195,12 +180,10 @@ void FanRemoteGPIO::turnFan(bool on) { bool FanRemoteGPIO::available() { this->looping = true; if (this->heldPin >= 0 && this->heldUntil != 0 && this->heldUntil <= millis()) { - Serial.println("timed release!"); digitalWrite(this->heldPin, HIGH); this->heldPin = -1; if ((queue.count()) > 0) { QueuedPress queued = queue.pop(); - Serial.println("Queue in use"); press(queued.pin, queued.time); } return true; @@ -254,8 +237,6 @@ void FanRemoteGPIO::press(int pin) { * @param time Delay before releasing, in milliseconds. */ void FanRemoteGPIO::press(int pin, int time) { - Serial.print("Pressed"); - Serial.println(pin); if (pin < 0) return; if (this->heldPin > -1) { @@ -271,8 +252,6 @@ void FanRemoteGPIO::press(int pin, int time) { this->heldUntil = millis() + time; } else { if (time > 0) delay(time); - Serial.print("Released"); - Serial.println(pin); digitalWrite(pin, HIGH); } } From 355d94d4985f63b9d22fb02040356133b7e978fb Mon Sep 17 00:00:00 2001 From: Ricky Date: Sat, 21 Jan 2017 23:57:21 -0800 Subject: [PATCH 3/3] Optionally specify protocol, pulselength in mqtt message --- _433toMQTTto433nFan_ESP8266.ino | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/_433toMQTTto433nFan_ESP8266.ino b/_433toMQTTto433nFan_ESP8266.ino index 4c16e64..e891d9f 100644 --- a/_433toMQTTto433nFan_ESP8266.ino +++ b/_433toMQTTto433nFan_ESP8266.ino @@ -330,12 +330,21 @@ void receivingMQTT(String topicNameRec, String callbackstring) { trc(datacallback); unsigned long data = strtoul(datacallback, NULL, 10); // we will not be able to pass value > 4294967295 trc(String(data)); - - if (topicNameRec == subjectMQTTto433){ - trc("Send received data by RF 433"); - //send received MQTT value by RF signal (example of signal sent data = 5264660) - mySwitch.send(data, 24); - } + String topicNamePart = topicNameRec.substring(0, topicNameRec.lastIndexOf("/")); + if (topicNameRec == subjectMQTTto433) { + mySwitch.setProtocol(1); // default + mySwitch.setPulseLength(350); // default + trc("Send received data by RF 433"); + //send received MQTT value by RF signal (example of signal sent data = 5264660) + mySwitch.send(data, 24); + } else if (topicNamePart == subjectMQTTto433) { + trc("Send received data by RF 433 with custom protocol/pulseLength"); + String s = topicNameRec.substring(topicNameRec.lastIndexOf("/") + 1); + int sep = s.indexOf("-"); + mySwitch.setProtocol(s.substring(0, sep).toInt()); + mySwitch.setPulseLength(s.substring(sep + 1).toInt()); + mySwitch.send(data, 24); + } /*TODO: Disabled IR] //send received MQTT value by IR signal (example of signal sent data = 1086296175) if (topicNameRec == subjectMQTTtoIRCOOLIX)