RF driver (receiver RF directly with SYN590R or similar)

* test

* T

* T

* W

* Update RCSwitch.cpp

* t

* w

* Update RCSwitch.h

* Update RCSwitch.cpp

* w

* ww

* Update RCSwitch.cpp

* t

* ttt

* test

* dbg

* Update RCSwitch.cpp

* Update RCSwitch.cpp

* ww

* Update drv_rc.cpp

* c

* Update RCSwitch.h

* make

* fix

* Update drv_rc.cpp

* wwww

* wwwwwwwwwww

* Update drv_rc.cpp

* fix

* dsfsdsd

* IOR_RCRecv

* Update RCSwitch.cpp

* test

* ffffffffffffx

* sds

* try

* fx

* tttttttt

* fixes

* fx

* hold

* hide debug vars

platforms/obk_main.mk

@@ -171,7 +171,9 @@ OBKM_SRC  += $(OBK_SRCS)i2c/drv_i2c_mcp23017.c
 OBKM_SRC  += $(OBK_SRCS)i2c/drv_i2c_tc74.c
 
 OBKM_SRC_CXX += $(OBK_SRCS)driver/drv_ir.cpp
+OBKM_SRC_CXX += $(OBK_SRCS)driver/drv_rc.cpp
 OBKM_SRC_CXX += $(OBK_SRCS)driver/drv_ir_new.cpp
+OBKM_SRC_CXX += $(OBK_SRCS)libraries/rc-switch/src/RCSwitch.cpp
 OBKM_SRC_CXX += $(OBK_SRCS)libraries/IRremoteESP8266/src/IRac.cpp
 OBKM_SRC_CXX += $(OBK_SRCS)libraries/IRremoteESP8266/src/IRproto.cpp
 OBKM_SRC_CXX += $(OBK_SRCS)libraries/IRremoteESP8266/src/IRrecv.cpp

src/cmnds/cmd_eventHandlers.c

@@ -234,6 +234,8 @@ int EVENT_ParseEventName(const char *s) {
 		return CMD_EVENT_ON_HTTP;
 	if (!stricmp(s, "OnDiscovery"))
 		return CMD_EVENT_ON_DISCOVERY;
+	if (!stricmp(s, "RC"))
+		return CMD_EVENT_RC;
 	if (isdigit((unsigned char)*s)) {
 		return atoi(s);
 	}

src/cmnds/cmd_public.h

@@ -172,6 +172,8 @@ enum EventCode {
 
 	CMD_EVENT_ON_DISCOVERY,
 
+	CMD_EVENT_RC,
+
 	// must be lower than 256
 	CMD_EVENT_MAX_TYPES
 };

src/driver/drv_main.c

@@ -5,6 +5,7 @@
 #include "drv_bl_shared.h"
 #include "drv_cse7766.h"
 #include "drv_ir.h"
+#include "drv_rc.h"
 #include "drv_local.h"
 #include "drv_ntp.h"
 #include "drv_deviceclock.h"
@@ -757,6 +758,22 @@ static driver_t g_drivers[] = {
 	false,                                   // loaded
 	},
 #endif
+#if ENABLE_DRIVER_RC
+		//drvdetail:{"name":"RC",
+		//drvdetail:"title":"TODO",
+		//drvdetail:"descr":"",
+		//drvdetail:"requires":""}
+	{ "RC",                                  // Driver Name
+	DRV_RC_Init,                             // Init
+	NULL,                                    // onEverySecond
+	RC_AppendInformationToHTTPIndexPage,                                    // appendInformationToHTTPIndexPage
+	DRV_RC_RunFrame,                         // runQuickTick
+	NULL,                                    // stopFunction
+	NULL,                                    // onChannelChanged
+	NULL,                                    // onHassDiscovery
+	false,                                   // loaded
+	},
+#endif
 #if ENABLE_DRIVER_IR2
 	//drvdetail:{"name":"IR2",
 	//drvdetail:"title":"TODO",

src/driver/drv_rc.cpp

@@ -0,0 +1,101 @@
+
+#include "../obk_config.h"
+
+#if ENABLE_DRIVER_RC
+
+extern "C" {
+	// these cause error: conflicting declaration of 'int bk_wlan_mcu_suppress_and_sleep(unsigned int)' with 'C' linkage
+#include "../new_common.h"
+#include "../httpserver/new_http.h"
+#include "../logging/logging.h"
+#include "../new_pins.h"
+#include "../new_cfg.h"
+#include "../cmnds/cmd_public.h"
+
+}
+
+#include "drv_rc.h"
+#include "../libraries/rc-switch/src/RCSwitch.h"
+
+RCSwitch mySwitch = RCSwitch();
+void DRV_RC_Init() {
+	// allow user to change them
+	int pin = -1;
+	bool pup = true;
+	pin = PIN_FindPinIndexForRole(IOR_RCRecv, pin);
+	if (pin == -1)
+	{
+		pin = PIN_FindPinIndexForRole(IOR_RCRecv_nPup, pin);
+		if (pin >= 0)
+			pup = false;
+	}
+	ADDLOG_INFO(LOG_FEATURE_IR, "DRV_RC_Init: passing pin %i\n", pin);
+	mySwitch.enableReceive(pin, pup);  // Receiver on interrupt 0 => that is pin #2
+}
+//extern long g_micros;
+//extern int rc_triggers;
+//extern int g_rcpin;
+//extern int rc_checkedProtocols;
+//extern int rc_singleRepeats;
+//extern int rc_repeats;
+static int rc_totalDecoded = 0;
+
+void RC_AppendInformationToHTTPIndexPage(http_request_t *request, int bPreState) {
+
+	if (bPreState) {
+	}
+	else {
+		hprintf255(request, "<h3>RC signals decoded: %i</h3>", rc_totalDecoded);
+		//hprintf255(request, "<h3>Triggers: %i</h3>", (int)rc_triggers);
+		//hprintf255(request, "<h3>Micros: %i</h3>", (int)g_micros);
+		//hprintf255(request, "<h3>g_rcpin: %i</h3>", (int)g_rcpin);
+		//hprintf255(request, "<h3>rc_checkedProtocols: %i</h3>", (int)rc_checkedProtocols);
+		//hprintf255(request, "<h3>rc_singleRepeats: %i</h3>", (int)rc_singleRepeats);
+		//hprintf255(request, "<h3>rc_repeats: %i</h3>", (int)rc_repeats);
+	}
+}
+unsigned long rc_prev = 0;
+int loopsUntilClear = 0;
+void DRV_RC_RunFrame() {
+	if (loopsUntilClear) {
+		loopsUntilClear--;
+		if (loopsUntilClear <= 0) {
+			rc_prev = 0;
+			ADDLOG_INFO(LOG_FEATURE_IR, "Clearing hold timer\n");
+		}
+	}
+	if (mySwitch.available()) {
+		rc_totalDecoded++;
+
+		unsigned long rc_now = mySwitch.getReceivedValue();
+		int bHold = 0;
+		if (rc_now != rc_prev) {
+			rc_prev = rc_now;
+		}
+		else {
+			bHold = 1;
+		}
+		loopsUntilClear = 15;
+		// TODO 64 bit
+		// generic
+		// addEventHandler RC 1234 toggleChannel 5 123
+		// on first receive
+		// addEventHandler2 RC 1234 0 toggleChannel 5 123
+		// on hold
+		// addEventHandler2 RC 1234 1 toggleChannel 5 123
+		ADDLOG_INFO(LOG_FEATURE_IR, "Received %lu / %u bit protocol %u, hold %i\n",
+			rc_now,
+			mySwitch.getReceivedBitlength(),
+			mySwitch.getReceivedProtocol(),
+			bHold);
+		EventHandlers_FireEvent2(CMD_EVENT_RC, mySwitch.getReceivedValue(), bHold);
+
+
+		mySwitch.resetAvailable();
+	}
+}
+
+
+#endif
+
+

src/driver/drv_rc.h

@@ -0,0 +1,17 @@
+#ifndef __DRV_RC_H__
+#define __DRV_RC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void DRV_RC_Init();
+void DRV_RC_RunFrame();
+void RC_AppendInformationToHTTPIndexPage(http_request_t *request, int bPreState);
+
+#ifdef __cplusplus
+}
+
+#endif
+#endif
+

src/httpserver/new_http.c

@@ -558,6 +558,8 @@ const char* htmlPinRoleNames[] = {
 	"StripState",
 	"StripState_n",
 	"HLW_8112_SCSN",
+	"RCRecv",
+	"RCRecv_nPup",
 	"error",
 	"error",
 	"error",

src/libraries/rc-switch/.gitignore

@@ -0,0 +1,17 @@
+# Mac stuff
+.DS_Store
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+

src/libraries/rc-switch/README.md

@@ -0,0 +1,16 @@
+**Modified Tasmota Fork of RC-SWITCH by @sui77 and @1technophile**
+
+## Info
+
+This will most likely work with all popular low cost power outlet sockets.
+
+All you need is a 315/433MHz AM transmitter and one
+or more devices with one of the supported chipsets:
+
+ - SC5262 / SC5272
+ - HX2262 / HX2272
+ - PT2262 / PT2272
+ - EV1527 / RT1527 / FP1527 / HS1527 
+ - Intertechno outlets
+ - HT6P20X
+

src/libraries/rc-switch/examples/ReceiveDemo_Advanced/ReceiveDemo_Advanced.ino

@@ -0,0 +1,24 @@
+/*
+  Example for receiving
+  
+  https://github.com/sui77/rc-switch/
+  
+  If you want to visualize a telegram copy the raw data and 
+  paste it into http://test.sui.li/oszi/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+  Serial.begin(9600);
+  mySwitch.enableReceive(0);  // Receiver on interrupt 0 => that is pin #2
+}
+
+void loop() {
+  if (mySwitch.available()) {
+    output(mySwitch.getReceivedValue(), mySwitch.getReceivedBitlength(), mySwitch.getReceivedDelay(), mySwitch.getReceivedRawdata(),mySwitch.getReceivedProtocol());
+    mySwitch.resetAvailable();
+  }
+}

src/libraries/rc-switch/examples/ReceiveDemo_Advanced/output.ino

@@ -0,0 +1,70 @@
+static const char* bin2tristate(const char* bin);
+static char * dec2binWzerofill(unsigned long Dec, unsigned int bitLength);
+
+void output(unsigned long decimal, unsigned int length, unsigned int delay, unsigned int* raw, unsigned int protocol) {
+
+  const char* b = dec2binWzerofill(decimal, length);
+  Serial.print("Decimal: ");
+  Serial.print(decimal);
+  Serial.print(" (");
+  Serial.print( length );
+  Serial.print("Bit) Binary: ");
+  Serial.print( b );
+  Serial.print(" Tri-State: ");
+  Serial.print( bin2tristate( b) );
+  Serial.print(" PulseLength: ");
+  Serial.print(delay);
+  Serial.print(" microseconds");
+  Serial.print(" Protocol: ");
+  Serial.println(protocol);
+  
+  Serial.print("Raw data: ");
+  for (unsigned int i=0; i<= length*2; i++) {
+    Serial.print(raw[i]);
+    Serial.print(",");
+  }
+  Serial.println();
+  Serial.println();
+}
+
+static const char* bin2tristate(const char* bin) {
+  static char returnValue[50];
+  int pos = 0;
+  int pos2 = 0;
+  while (bin[pos]!='\0' && bin[pos+1]!='\0') {
+    if (bin[pos]=='0' && bin[pos+1]=='0') {
+      returnValue[pos2] = '0';
+    } else if (bin[pos]=='1' && bin[pos+1]=='1') {
+      returnValue[pos2] = '1';
+    } else if (bin[pos]=='0' && bin[pos+1]=='1') {
+      returnValue[pos2] = 'F';
+    } else {
+      return "not applicable";
+    }
+    pos = pos+2;
+    pos2++;
+  }
+  returnValue[pos2] = '\0';
+  return returnValue;
+}
+
+static char * dec2binWzerofill(unsigned long Dec, unsigned int bitLength) {
+  static char bin[64]; 
+  unsigned int i=0;
+
+  while (Dec > 0) {
+    bin[32+i++] = ((Dec & 1) > 0) ? '1' : '0';
+    Dec = Dec >> 1;
+  }
+
+  for (unsigned int j = 0; j< bitLength; j++) {
+    if (j >= bitLength - i) {
+      bin[j] = bin[ 31 + i - (j - (bitLength - i)) ];
+    } else {
+      bin[j] = '0';
+    }
+  }
+  bin[bitLength] = '\0';
+  
+  return bin;
+}

src/libraries/rc-switch/examples/ReceiveDemo_Simple/ReceiveDemo_Simple.ino

@@ -0,0 +1,29 @@
+/*
+  Simple example for receiving
+  
+  https://github.com/sui77/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+  Serial.begin(9600);
+  mySwitch.enableReceive(0);  // Receiver on interrupt 0 => that is pin #2
+}
+
+void loop() {
+  if (mySwitch.available()) {
+    
+    Serial.print("Received ");
+    Serial.print( mySwitch.getReceivedValue() );
+    Serial.print(" / ");
+    Serial.print( mySwitch.getReceivedBitlength() );
+    Serial.print("bit ");
+    Serial.print("Protocol: ");
+    Serial.println( mySwitch.getReceivedProtocol() );
+
+    mySwitch.resetAvailable();
+  }
+}

src/libraries/rc-switch/examples/SendDemo/SendDemo.ino

@@ -0,0 +1,57 @@
+/*
+  Example for different sending methods
+  
+  https://github.com/sui77/rc-switch/
+  
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  Serial.begin(9600);
+  
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+  
+  // Optional set protocol (default is 1, will work for most outlets)
+  // mySwitch.setProtocol(2);
+
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+  // Optional set number of transmission repetitions.
+  // mySwitch.setRepeatTransmit(15);
+  
+}
+
+void loop() {
+
+  /* See Example: TypeA_WithDIPSwitches */
+  mySwitch.switchOn("11111", "00010");
+  delay(1000);
+  mySwitch.switchOff("11111", "00010");
+  delay(1000);
+
+  /* Same switch as above, but using decimal code */
+  mySwitch.send(5393, 24);
+  delay(1000);  
+  mySwitch.send(5396, 24);
+  delay(1000);  
+
+  /* Same switch as above, but using binary code */
+  mySwitch.send("000000000001010100010001");
+  delay(1000);  
+  mySwitch.send("000000000001010100010100");
+  delay(1000);
+
+  /* Same switch as above, but tri-state code */ 
+  mySwitch.sendTriState("00000FFF0F0F");
+  delay(1000);  
+  mySwitch.sendTriState("00000FFF0FF0");
+  delay(1000);
+
+  delay(20000);
+}

src/libraries/rc-switch/examples/TypeA_WithDIPSwitches/TypeA_WithDIPSwitches.ino

@@ -0,0 +1,40 @@
+/*
+  Example for outlets which are configured with a 10 pole DIP switch.
+  
+  https://github.com/sui77/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+}
+
+void loop() {
+
+  // Switch on:
+  // The first parameter represents the setting of the first 5 DIP switches. 
+  // In this example it's ON-ON-OFF-OFF-ON.
+  // 
+  // The second parameter represents the setting of the last 5 DIP switches. 
+  // In this example the last 5 DIP switches are OFF-ON-OFF-ON-OFF.  
+  mySwitch.switchOn("11001", "01010");
+
+  // Wait a second
+  delay(1000);
+  
+  // Switch off
+  mySwitch.switchOff("11001", "01010");
+  
+  // Wait another second
+  delay(1000);
+  
+}

src/libraries/rc-switch/examples/TypeA_WithDIPSwitches_Lightweight/TypeA_WithDIPSwitches_Lightweight.ino

@@ -0,0 +1,43 @@
+/*
+  This is a minimal sketch without using the library at all but only works for
+  the 10 pole dip switch sockets. It saves a lot of memory and thus might be 
+  very useful to use with ATTinys :)
+  
+  https://github.com/sui77/rc-switch/
+*/
+
+int RCLpin = 7;
+
+void setup() {
+    pinMode(RCLpin, OUTPUT);
+}
+
+void loop() {
+    RCLswitch(0b010001000001);  // DIPs an Steckdose: 0100010000 An:01
+    delay(2000);
+
+    RCLswitch(0b010001000010);  // DIPs an Steckdose: 0100010000 Aus:10
+    delay(2000);    
+}
+
+void RCLswitch(uint16_t code) {
+    for (int nRepeat=0; nRepeat<6; nRepeat++) {
+        for (int i=4; i<16; i++) {
+            RCLtransmit(1,3);
+            if (((code << (i-4)) & 2048) > 0) {
+                RCLtransmit(1,3);
+            } else {
+                RCLtransmit(3,1);
+            }
+        }
+        RCLtransmit(1,31);    
+    }
+}
+
+void RCLtransmit(int nHighPulses, int nLowPulses) {
+    digitalWrite(RCLpin, HIGH);
+    delayMicroseconds( 350 * nHighPulses);
+    digitalWrite(RCLpin, LOW);
+    delayMicroseconds( 350 * nLowPulses);
+}
+

src/libraries/rc-switch/examples/TypeB_WithRotaryOrSlidingSwitches/TypeB_WithRotaryOrSlidingSwitches.ino

@@ -0,0 +1,40 @@
+/*
+  Example for outlets which are configured with two rotary/sliding switches.
+  
+  https://github.com/sui77/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+  
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+}
+
+void loop() {
+
+  // Switch on:
+  // The first parameter represents the setting of the first rotary switch. 
+  // In this example it's switched to "1" or "A" or "I". 
+  // 
+  // The second parameter represents the setting of the second rotary switch. 
+  // In this example it's switched to "4" or "D" or "IV". 
+  mySwitch.switchOn(1, 4);
+
+  // Wait a second
+  delay(1000);
+  
+  // Switch off
+  mySwitch.switchOff(1, 4);
+  
+  // Wait another second
+  delay(1000);
+  
+}

src/libraries/rc-switch/examples/TypeC_Intertechno/TypeC_Intertechno.ino

@@ -0,0 +1,40 @@
+/*
+  Example for Intertechno outlets
+  
+  https://github.com/sui77/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+  
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+}
+
+void loop() {
+
+  // Switch on:
+  // The first parameter represents the familycode (a, b, c, ... f)
+  // The second parameter represents the group number
+  // The third parameter represents the device number
+  // 
+  // In this example it's family 'b', group #3, device #2 
+  mySwitch.switchOn('b', 3, 2);
+
+  // Wait a second
+  delay(1000);
+  
+  // Switch off
+  mySwitch.switchOff('b', 3, 2);
+  
+  // Wait another second
+  delay(1000);
+  
+}

src/libraries/rc-switch/examples/TypeD_REV/TypeD_REV.ino

@@ -0,0 +1,41 @@
+/*
+  Example for REV outlets (e.g. 8342L)
+  
+  https://github.com/sui77/rc-switch/
+  
+  Need help? http://forum.ardumote.com
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+  
+  // set pulse length.
+  mySwitch.setPulseLength(360);
+  
+}
+
+void loop() {
+
+  // Switch on:
+  // The first parameter represents the channel (a, b, c, d)
+  // The second parameter represents the device number
+  // 
+  // In this example it's family 'd', device #2 
+  mySwitch.switchOn('d', 2);
+
+  // Wait a second
+  delay(1000);
+  
+  // Switch off
+  mySwitch.switchOff('d', 2);
+  
+  // Wait another second
+  delay(1000);
+  
+}

src/libraries/rc-switch/examples/Webserver/Webserver.ino

@@ -0,0 +1,154 @@
+/*
+  A simple RCSwitch/Ethernet/Webserver demo
+  
+  https://github.com/sui77/rc-switch/
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <RCSwitch.h>
+
+// Ethernet configuration
+uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // MAC Address
+uint8_t ip[] = { 192,168,0, 2 };                        // IP Address
+EthernetServer server(80);                           // Server Port 80
+
+// RCSwitch configuration
+RCSwitch mySwitch = RCSwitch();
+int RCTransmissionPin = 7;
+
+// More to do...
+// You should also modify the processCommand() and 
+// httpResponseHome() functions to fit your needs.
+
+
+
+/**
+ * Setup
+ */
+void setup() {
+  Ethernet.begin(mac, ip);
+  server.begin();
+  mySwitch.enableTransmit( RCTransmissionPin );
+}
+
+/**
+ * Loop
+ */
+void loop() {
+  char* command = httpServer();
+}
+
+/**
+ * Command dispatcher
+ */
+void processCommand(char* command) {
+  if        (strcmp(command, "1-on") == 0) {
+    mySwitch.switchOn(1,1);
+  } else if (strcmp(command, "1-off") == 0) {
+    mySwitch.switchOff(1,1);
+  } else if (strcmp(command, "2-on") == 0) {
+    mySwitch.switchOn(1,2);
+  } else if (strcmp(command, "2-off") == 0) {
+    mySwitch.switchOff(1,2);
+  }
+}
+
+/**
+ * HTTP Response with homepage
+ */
+void httpResponseHome(EthernetClient c) {
+  c.println("HTTP/1.1 200 OK");
+  c.println("Content-Type: text/html");
+  c.println();
+  c.println("<html>");
+  c.println("<head>");
+  c.println(    "<title>RCSwitch Webserver Demo</title>");
+  c.println(    "<style>");
+  c.println(        "body { font-family: Arial, sans-serif; font-size:12px; }");
+  c.println(    "</style>");
+  c.println("</head>");
+  c.println("<body>");
+  c.println(    "<h1>RCSwitch Webserver Demo</h1>");
+  c.println(    "<ul>");
+  c.println(        "<li><a href=\"./?1-on\">Switch #1 on</a></li>");
+  c.println(        "<li><a href=\"./?1-off\">Switch #1 off</a></li>");
+  c.println(    "</ul>");
+  c.println(    "<ul>");
+  c.println(        "<li><a href=\"./?2-on\">Switch #2 on</a></li>");
+  c.println(        "<li><a href=\"./?2-off\">Switch #2 off</a></li>");
+  c.println(    "</ul>");
+  c.println(    "<hr>");
+  c.println(    "<a href=\"https://github.com/sui77/rc-switch/\">https://github.com/sui77/rc-switch/</a>");
+  c.println("</body>");
+  c.println("</html>");
+}
+
+/**
+ * HTTP Redirect to homepage
+ */
+void httpResponseRedirect(EthernetClient c) {
+  c.println("HTTP/1.1 301 Found");
+  c.println("Location: /");
+  c.println();
+}
+
+/**
+ * HTTP Response 414 error
+ * Command must not be longer than 30 characters
+ **/
+void httpResponse414(EthernetClient c) {
+  c.println("HTTP/1.1 414 Request URI too long");
+  c.println("Content-Type: text/plain");
+  c.println();
+  c.println("414 Request URI too long");
+}
+
+/**
+ * Process HTTP requests, parse first request header line and 
+ * call processCommand with GET query string (everything after
+ * the ? question mark in the URL).
+ */
+char*  httpServer() {
+  EthernetClient client = server.available();
+  if (client) {
+    char sReturnCommand[32];
+    int nCommandPos=-1;
+    sReturnCommand[0] = '\0';
+    while (client.connected()) {
+      if (client.available()) {
+        char c = client.read();
+        if ((c == '\n') || (c == ' ' && nCommandPos>-1)) {
+          sReturnCommand[nCommandPos] = '\0';
+          if (strcmp(sReturnCommand, "\0") == 0) {
+            httpResponseHome(client);
+          } else {
+            processCommand(sReturnCommand);
+            httpResponseRedirect(client);
+          }
+          break;
+        }
+        if (nCommandPos>-1) {
+          sReturnCommand[nCommandPos++] = c;
+        }
+        if (c == '?' && nCommandPos == -1) {
+          nCommandPos = 0;
+        }
+      }
+      if (nCommandPos > 30) {
+        httpResponse414(client);
+        sReturnCommand[0] = '\0';
+        break;
+      }
+    }
+    if (nCommandPos!=-1) {
+      sReturnCommand[nCommandPos] = '\0';
+    }
+    // give the web browser time to receive the data
+    delay(1);
+    client.stop();
+    
+    return sReturnCommand;
+  }
+  return '\0';
+}

src/libraries/rc-switch/keywords.txt

@@ -0,0 +1,57 @@
+#######################################
+# Syntax Coloring Map For RCSwitch
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+RCSwitch	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+##########
+#SENDS Begin
+##########
+switchOn		KEYWORD2
+switchOff		KEYWORD2
+sendTriState		KEYWORD2
+send			KEYWORD2
+##########
+#SENDS End
+##########
+
+##########
+#RECEIVE Begin
+##########
+enableReceive		KEYWORD2
+disableReceive		KEYWORD2
+available		KEYWORD2	
+resetAvailable		KEYWORD2
+setReceiveTolerance	KEYWORD2
+getReceivedValue	KEYWORD2
+getReceivedBitlength	KEYWORD2
+getReceivedDelay	KEYWORD2
+getReceivedProtocol	KEYWORD2
+getReceivedRawdata	KEYWORD2
+##########
+#RECEIVE End
+##########
+
+##########
+#OTHERS Begin
+##########
+enableTransmit		KEYWORD2
+disableTransmit		KEYWORD2
+setPulseLength		KEYWORD2
+setProtocol		KEYWORD2
+setRepeatTransmit	KEYWORD2
+##########
+#OTHERS End
+##########
+
+#######################################
+# Constants (LITERAL1)
+#######################################

src/libraries/rc-switch/library.json

@@ -0,0 +1,19 @@
+{
+  "name": "rc-switch",
+  "description": "Use ESP8266/ESP32 to operate remote radio controlled devices",
+  "keywords": "rf, radio, wireless",
+  "authors":
+  {
+    "name": "Theo Arends"
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/arendst/Tasmota.git"
+  },
+  "version": "1.0.0",
+  "frameworks": [
+        "arduino"
+  ],
+  "platforms": "*"
+}

src/libraries/rc-switch/library.properties

@@ -0,0 +1,10 @@
+name=rc-switch
+version=1.0.0
+author=@sui77 @1technophile and more
+maintainer=Theo Arends
+sentence=Operate 433/315Mhz devices.
+paragraph=Use ESP8266/ESP32 to operate remote radio controlled devices.
+category=Device Control
+url=https://github.com/arendst/Tasmota
+architectures=esp8266,esp32
+includes=RCSwitch.h

src/libraries/rc-switch/platformio.ini

@@ -0,0 +1,103 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[platformio]
+src_dir = examples/ReceiveDemo_Advanced
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;                                 ENVIRONMENT CHOICE                                   ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;Uncomment the env line corresponding to your board and modules required,              ;
+;you can also adapt the modules by removing the corresponding lines in the env detail  ;
+; if you go to the build flag section of your env you will see that some user_config.h ;
+; parameters can be overwritten here, for example the gateway name.                    ;
+; If you want to avoid the lost of your environments at each update you can put them   ;
+; into a separate file called prod_env.ini, it will be automatically read by pio       ;
+; an example (prod_env.ini.example) is available into the same folder as this file.    ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;default_envs = sonoff-basic-rfr3
+;default_envs = esp32dev-rf
+;default_envs = nodemcuv2-rf
+;default_envs = rf-wifi-gateway
+;default_envs = uno-rf
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;                              ENVIRONMENTS PARAMETERS                                 ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;Libraries and parameters shared accross environements                                 ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+
+[env]
+lib_extra_dirs = .
+framework = arduino
+build_flags =
+  -w ; supress all warnings
+monitor_speed = 115200
+
+[com]
+esp8266_platform = espressif8266@2.2.3
+esp32_platform = espressif32@1.11.1
+atmelavr_platform = atmelavr@1.13.0
+
+[com-esp]
+build_flags =
+  ${env.build_flags}
+
+[com-arduino]
+build_flags =
+  ${env.build_flags}
+
+[com-arduino-low-memory]
+build_flags =
+  ${env.build_flags}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;                                 ENVIRONMENTS LIST                                    ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;List of environments that can be build                                                ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+[env:esp32dev-rf]
+platform = ${com.esp32_platform}
+board = esp32dev
+build_flags = 
+  ${com-esp.build_flags}
+
+[env:nodemcuv2-rf]
+platform = ${com.esp8266_platform}
+board = nodemcuv2
+build_flags = 
+  ${com-esp.build_flags}
+board_build.flash_mode = dout
+
+[env:rf-wifi-gateway]
+platform = ${com.esp8266_platform}
+board = nodemcuv2
+build_flags = 
+  ${com-esp.build_flags}
+board_build.flash_mode = dout
+
+
+[env:sonoff-basic-rfr3]
+platform = ${com.esp8266_platform}
+board = esp8285
+build_flags = 
+  ${com-esp.build_flags}
+board_build.flash_mode = dout
+
+[env:uno-rf]
+platform = ${com.atmelavr_platform}
+board = uno
+build_flags = 
+  ${com-arduino-low-memory.build_flags}

src/libraries/rc-switch/src/RCSwitch.h

@@ -0,0 +1,212 @@
+/*
+  RCSwitch - Arduino libary for remote control outlet switches
+  Copyright (c) 2011 Suat Özgür.  All right reserved.
+
+  Contributors:
+  - Andre Koehler / info(at)tomate-online(dot)de
+  - Gordeev Andrey Vladimirovich / gordeev(at)openpyro(dot)com
+  - Skineffect / http://forum.ardumote.com/viewtopic.php?f=2&t=46
+  - Dominik Fischer / dom_fischer(at)web(dot)de
+  - Frank Oltmanns / <first name>.<last name>(at)gmail(dot)com
+  - Max Horn / max(at)quendi(dot)de
+  - Robert ter Vehn / <first name>.<last name>(at)gmail(dot)com
+
+  Project home: https://github.com/sui77/rc-switch/
+
+  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 _RCSwitch_h
+#define _RCSwitch_h
+
+#if defined(ARDUINO) && ARDUINO >= 100
+    #include "Arduino.h"
+#elif defined(ENERGIA) // LaunchPad, FraunchPad and StellarPad specific
+    #include "Energia.h"
+#elif defined(RPI) // Raspberry Pi
+    #define RaspberryPi
+
+    // Include libraries for RPi:
+    #include <string.h> /* memcpy */
+    #include <stdlib.h> /* abs */
+    #include <wiringPi.h>
+#elif defined(SPARK)
+    #include "application.h"
+#else
+   // #include "WProgram.h"
+	#include <string.h> /* memcpy */
+	#include <stdlib.h> /* abs */
+extern "C" {
+#include "../../../obk_config.h"
+#include "../../../new_common.h"
+#include "../../../logging/logging.h"
+#include "../../../hal/hal_pins.h"
+}
+#endif
+
+#include <stdint.h>
+
+
+// At least for the ATTiny X4/X5, receiving has to be disabled due to
+// missing libm depencies (udivmodhi4)
+#if defined( __AVR_ATtinyX5__ ) or defined ( __AVR_ATtinyX4__ )
+#define RCSwitchDisableReceiving
+#endif
+
+// Number of maximum high/Low changes per packet.
+// We can handle up to 36 bit * 2 H/L changes per bit + 2 for sync
+// Для keeloq нужно увеличить RCSWITCH_MAX_CHANGES до 23+1+66*2+1=157
+//#define RCSWITCH_MAX_CHANGES 75        // default 75 - longest protocol that requires this buffer size is 38/nexus
+#define RCSWITCH_MAX_CHANGES 131        // default 75 - Supports 64 too
+
+// separationLimit: minimum microseconds between received codes, closer codes are ignored.
+// according to discussion on issue #14 it might be more suitable to set the separation
+// limit to the same time as the 'low' part of the sync signal for the current protocol.
+// should be set to the minimum value of pulselength * the sync signal
+#define RCSWITCH_SEPARATION_LIMIT 3600
+
+class RCSwitch {
+
+  public:
+    RCSwitch();
+
+    void switchOn(int nGroupNumber, int nSwitchNumber);
+    void switchOff(int nGroupNumber, int nSwitchNumber);
+    void switchOn(const char* sGroup, int nSwitchNumber);
+    void switchOff(const char* sGroup, int nSwitchNumber);
+    void switchOn(char sFamily, int nGroup, int nDevice);
+    void switchOff(char sFamily, int nGroup, int nDevice);
+    void switchOn(const char* sGroup, const char* sDevice);
+    void switchOff(const char* sGroup, const char* sDevice);
+    void switchOn(char sGroup, int nDevice);
+    void switchOff(char sGroup, int nDevice);
+
+    void sendTriState(const char* sCodeWord);
+    void sendGeneric(unsigned long long code, unsigned int length);
+    void sendGeneric(const char* sCodeWord);
+
+    #if not defined( RCSwitchDisableReceiving )
+    void enableReceive(int interrupt, bool pup);
+    void enableReceive();
+    void disableReceive();
+    bool available();
+    void resetAvailable();
+
+    unsigned long long getReceivedValue();
+    unsigned int getReceivedBitlength();
+    unsigned int getReceivedDelay();
+    unsigned int getReceivedProtocol();
+    unsigned int* getReceivedRawdata();
+    uint8_t getNumProtos();
+    #endif
+
+    void enableTransmit(int nTransmitterPin);
+    void disableTransmit();
+    void setPulseLength(int nPulseLength);
+    void setRepeatTransmit(int nRepeatTransmit);
+    #if not defined( RCSwitchDisableReceiving )
+    void setReceiveTolerance(int nPercent);
+    bool setReceiveProtocolMask(unsigned long long mask);
+    #endif
+
+    /**
+     * Description of a single pule, which consists of a high signal
+     * whose duration is "high" times the base pulse length, followed
+     * by a low signal lasting "low" times the base pulse length.
+     * Thus, the pulse overall lasts (high+low)*pulseLength
+     */
+    struct HighLow {
+        uint8_t high;
+        uint8_t low;
+    };
+
+    /**
+     * A "protocol" describes how zero and one bits are encoded into high/low
+     * pulses.
+     */
+    struct Protocol {
+        /** base pulse length in microseconds, e.g. 350 */
+        uint16_t pulseLength;
+        uint8_t PreambleFactor;
+        HighLow Preamble;
+        uint8_t HeaderFactor;
+        HighLow Header;
+
+        HighLow zero;
+        HighLow one;
+
+        /**
+         * If true, interchange high and low logic levels in all transmissions.
+         *
+         * By default, RCSwitch assumes that any signals it sends or receives
+         * can be broken down into pulses which start with a high signal level,
+         * followed by a a low signal level. This is e.g. the case for the
+         * popular PT 2260 encoder chip, and thus many switches out there.
+         *
+         * But some devices do it the other way around, and start with a low
+         * signal level, followed by a high signal level, e.g. the HT6P20B. To
+         * accommodate this, one can set invertedSignal to true, which causes
+         * RCSwitch to change how it interprets any HighLow struct FOO: It will
+         * then assume transmissions start with a low signal lasting
+         * FOO.high*pulseLength microseconds, followed by a high signal lasting
+         * FOO.low*pulseLength microseconds.
+         */
+        bool invertedSignal;
+        uint16_t Guard;
+    };
+
+    void setProtocol(Protocol protocol);
+    void setProtocol(int nProtocol);
+    void setProtocol(int nProtocol, int nPulseLength);
+
+  private:
+    char* getCodeWordA(const char* sGroup, const char* sDevice, bool bStatus);
+    char* getCodeWordB(int nGroupNumber, int nSwitchNumber, bool bStatus);
+    char* getCodeWordC(char sFamily, int nGroup, int nDevice, bool bStatus);
+    char* getCodeWordD(char group, int nDevice, bool bStatus);
+    void transmit(HighLow pulses);
+
+    #if not defined( RCSwitchDisableReceiving )
+public:
+    static void handleInterrupt(int xyz);
+private:
+    static bool receiveProtocol(const int p, unsigned int changeCount);
+    static bool updateSeparationLimit();
+    int nReceiverInterrupt;
+	bool bUsePullUp;
+    #endif
+    int nTransmitterPin;
+    int nRepeatTransmit;
+    Protocol protocol;
+
+    #if not defined( RCSwitchDisableReceiving )
+    static int nReceiveTolerance;
+    volatile static unsigned long long nReceivedValue;
+    volatile static unsigned long long nReceiveProtocolMask;
+    volatile static unsigned int nReceivedBitlength;
+    volatile static unsigned int nReceivedDelay;
+    volatile static unsigned int nReceivedProtocol;
+    static unsigned int nSeparationLimit;
+    /*
+     * timings[0] contains sync timing, followed by a number of bits
+     */
+    static unsigned int timings[RCSWITCH_MAX_CHANGES];
+    // буфер длительностей последних четырех пакетов, [0] - последний
+    static unsigned int buftimings[4];
+    #endif
+
+
+};
+
+#endif

src/new_pins.h

@@ -616,6 +616,20 @@ typedef enum ioRole_e {
 	//iodetail:"file":"new_pins.h",
 	//iodetail:"driver":"HLW8112SPI"}
 	IOR_HLW8112_SCSN,
+	//iodetail:{"name":"IOR_RCRecv",
+	//iodetail:"title":"IOR_RCRecv Pin",
+	//iodetail:"descr":"IOR_RCRecv.",
+	//iodetail:"enum":"IOR_RCRecv",
+	//iodetail:"file":"new_pins.h",
+	//iodetail:"driver":"RC"}
+	IOR_RCRecv,
+	//iodetail:{"name":"IOR_RCRecv_nPup",
+	//iodetail:"title":"IOR_RCRecv_nPup Pin",
+	//iodetail:"descr":"IOR_RCRecv_nPup.",
+	//iodetail:"enum":"IOR_RCRecv_nPup",
+	//iodetail:"file":"new_pins.h",
+	//iodetail:"driver":"RC"}
+	IOR_RCRecv_nPup,
 	//iodetail:{"name":"Total_Options",
 	//iodetail:"title":"TODO",
 	//iodetail:"descr":"Current total number of available IOR roles",

src/obk_config.h

@@ -289,6 +289,7 @@
 #define ENABLE_DRIVER_DDP						1
 #define ENABLE_DRIVER_SSDP						1
 #define ENABLE_DRIVER_IR						1
+#define ENABLE_DRIVER_RC						1
 // #define ENABLE_DRIVER_IR2					1
 #define ENABLE_DRIVER_DS1820					1
 #define ENABLE_DRIVER_CHT83XX					1