Merge pull request #6 from sinricpro/dev-2.2.3

2.2.3

Author: sivar2311

README.md

@@ -0,0 +1,179 @@
+/*
+ * This example needs SinricPro 2.2.2
+ * 
+ * If you encounter any issues:
+ * - enable serial debug (see section below)
+ * - open serial monitor and check whats happening
+ * - visit https://github.com/sinricpro/esp8266-esp32-sdk/issues and check for existing issues or open a new one
+*/
+
+// Uncomment the following line to enable serial debug output
+//#define ENABLE_DEBUG
+
+#ifdef ENABLE_DEBUG
+       #define DEBUG_ESP_PORT Serial
+       #define NODEBUG_WEBSOCKETS
+       #define NDEBUG
+#endif 
+
+#include <Arduino.h>
+#ifdef ESP8266 
+       #include <ESP8266WiFi.h>
+#endif 
+#ifdef ESP32   
+       #include <WiFi.h>
+#endif
+
+#include "SinricPro.h"
+#include "SinricProLock.h"
+
+#define WIFI_SSID         "YOUR_WIFI_SSID"    
+#define WIFI_PASS         "YOUR_WIFI_PASSWORD"
+#define APP_KEY           "YOUR_APP_KEY_HERE"      // Should look like "de0bxxxx-1x3x-4x3x-ax2x-5dabxxxxxxxx"
+#define APP_SECRET        "YOUR_APP_SECRET_HERE"   // Should look like "5f36xxxx-x3x7-4x3x-xexe-e86724a9xxxx-4c4axxxx-3x3x-x5xe-x9x3-333d65xxxxxx"
+#define GARAGEDOOR_ID     "YOUR_DEVICE_ID_HERE"    // Should look like "5dc1564130xxxxxxxxxxxxxx"
+#define BAUD_RATE         9600                     // Change baudrate to your need
+
+#define RELAY             D5    // PIN where relay is attachted to
+#define ENDSTOP_OPEN      D6    // PIN where open position reedswitch is connected to  (high = door is open   | low = door is NOT open)
+#define ENDSTOP_CLOSED    D7    // PIN where close position reedswitch is connected to (high = door is closed | low = door is NOT closed)
+#define MOVE_TIMEOUT      20000 // Timout (20 seconds) for door movement -> please use a value which fits to your open/close time but not more than 20 seconds
+#define RELAY_TIME        4000  // Relay high time (4 seconds) - usually between 2500 and 5000
+
+
+// Door state definitions
+#define DOOR_MOVING       0  // Door is not in close and not in open position...somewere between, might be moving
+#define DOOR_OPEN         1  // Door is in open position
+#define DOOR_CLOSED       2  // Door is in closed position
+#define DOOR_MALFUNCTION  3  // Malfunction! Door can't be open and closed at the same time
+
+/* function getDoorState() 
+ * returs door state (see section above)
+ */
+int getDoorState() {
+  if (digitalRead(ENDSTOP_CLOSED)==false && digitalRead(ENDSTOP_OPEN)==false) return DOOR_MOVING;
+  if (digitalRead(ENDSTOP_CLOSED)==false && digitalRead(ENDSTOP_OPEN)==true)  return DOOR_OPEN;
+  if (digitalRead(ENDSTOP_CLOSED)==true  && digitalRead(ENDSTOP_OPEN)==false) return DOOR_CLOSED;
+  return DOOR_MALFUNCTION;
+}
+
+int lastDoorState; // last known doorstate
+
+/* turnOnRelayAndWait
+ *
+ * function: turn on relay for a given time and waits until endstop gets triggered or timeout happened
+ *
+ * input:    relay_pin   = pin which is RELAY connected to
+ *           relay_time  = time in milliseconds to keep RELAY high
+ *           endstop_pin = pin which is MAGNET connected to
+ *           endstop_timeout = timeout time in milliseconds
+ * 
+ * return:   true if enstop is triggered within timeout time
+ *           false if endstop was not triggered within timeout time
+*/
+bool turnOnRelayAndWait(int relay_pin, unsigned long relay_time, int endstop_pin, unsigned long endstop_timeout) {
+  unsigned long startMillis = millis();
+
+  bool timeout = false; // timeout flag
+  bool success = false; // success flag
+  Serial.printf("RELAY: HIGH\r\n");
+
+  digitalWrite(relay_pin, HIGH); // turn on relay
+  bool relay_High = true; // relay flag
+
+  while (success==false && timeout==false) { // while operation is not completed and within timeout time
+    unsigned long actualMillis = millis();  
+
+    success = digitalRead(endstop_pin);                        // check endstop
+    timeout = (actualMillis - startMillis >= endstop_timeout); // check for timeout
+
+    // if relay_time is reached, turn off relay
+    if (relay_High == true && actualMillis - startMillis >= relay_time){
+      Serial.printf("RELAY: LOW\r\n");
+      digitalWrite(relay_pin, LOW); 
+      relay_High = false;
+    }
+    yield(); // make sure to keep esp stay alive ;)
+  }
+  digitalWrite(relay_pin, LOW); // turn off relay, just to be safe!
+  lastDoorState = getDoorState(); // update lastDoorState to prevent event sending
+  return success; 
+}
+
+bool onLockState(String deviceId, bool &lockState) {
+  int doorState = getDoorState();
+  if (doorState == DOOR_MALFUNCTION){
+    Serial.printf("Malfunction! Door is reporting to be open and closed at the same time!\r\n");
+    SinricPro.setResponseMessage("Error: malfunction!");
+    return false; 
+  } 
+  bool success = false;
+  if (lockState) { // close door
+    if (doorState == DOOR_CLOSED) return true; // door is allready closed return true
+    Serial.printf("Closing door...\r\n");
+    success = turnOnRelayAndWait(RELAY, RELAY_TIME, ENDSTOP_CLOSED, MOVE_TIMEOUT); // close the door
+    Serial.printf("%s\r\n", success?"Door is closed now.":"Error! Door did not close properly (timeout)!");
+  } else { // open door
+    if (doorState == DOOR_OPEN) return true; // door is allready open...return true
+    Serial.printf("Opening door...\r\n");
+    success = turnOnRelayAndWait(RELAY, RELAY_TIME, ENDSTOP_OPEN, MOVE_TIMEOUT); // open the door
+    Serial.printf("%s\r\n", success?"Door is open now.":"Error! Door did not open properly (timeout)!");
+  }
+  if (!success) SinricPro.setResponseMessage("Error: timeout!");
+  return success;
+}
+
+void handleManualDoorState() {
+  int actualDoorState = getDoorState();
+  if (actualDoorState != lastDoorState) {
+    SinricProLock& garageDoor = SinricPro[GARAGEDOOR_ID];
+    switch (actualDoorState) {
+      case DOOR_OPEN   :  Serial.printf("Door has been opened manually.\r\n");
+                          garageDoor.sendLockStateEvent(false);
+                          break;
+      case DOOR_CLOSED :  garageDoor.sendLockStateEvent(true);
+                          Serial.printf("Door has been closed manually.\r\n");
+                          break;
+      case DOOR_MOVING :  Serial.printf("Door is moving.\r\n");
+                          break;
+      default          :  Serial.printf("WARNING! DOOR HAS A MALFUNCTION!\r\n");
+                          break;
+    }
+    lastDoorState = actualDoorState;    
+  }
+}
+
+
+void setupWiFi() {
+  Serial.printf("\r\n[Wifi]: Connecting");
+  WiFi.begin(WIFI_SSID, WIFI_PASS);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.printf(".");
+    delay(250);
+  }
+  IPAddress localIP = WiFi.localIP();
+  Serial.printf("connected!\r\n[WiFi]: IP-Address is %d.%d.%d.%d\r\n", localIP[0], localIP[1], localIP[2], localIP[3]);
+}
+
+void setupSinricPro() {
+  SinricProLock &garageDoor = SinricPro[GARAGEDOOR_ID];
+  garageDoor.onLockState(onLockState);
+
+  SinricPro.begin(APP_KEY, APP_SECRET);
+}
+
+void setup() {
+  Serial.begin(BAUD_RATE);
+  pinMode(RELAY, OUTPUT); 
+  pinMode(ENDSTOP_OPEN, INPUT); 
+  pinMode(ENDSTOP_CLOSED, INPUT);
+  lastDoorState = getDoorState();
+  setupWiFi();
+  setupSinricPro();
+}
+
+void loop() {
+  SinricPro.handle();
+  handleManualDoorState();
+}

examples/GarageDoor/GarageDoor.ino

@@ -0,0 +1,6 @@
+# GarageDoorExample
+![Wiring](https://github.com/sivar2311/GarageDoorExample/raw/master/GarageDoor3_Steckplatine.png)
+  
+D5: connected to relay  
+D6: connected to reed_switch (OPEN ENDSTOP)  
+D7: connected to reed_switch (CLOSED ENDSTOP)  

examples/GarageDoor/GarageDoor3_Steckplatine.png

@@ -55,7 +55,7 @@ unsigned long lastBtnPress = 0;
  * return
  *  true if request should be marked as handled correctly / false if not
  */
-bool onPowerState(String deviceId, bool &state) {
+bool onPowerState(const String &deviceId, bool &state) {
   Serial.printf("Device %s turned %s (via SinricPro) \r\n", deviceId.c_str(), state?"on":"off");
   myPowerState = state;
   digitalWrite(LED_BUILTIN, myPowerState?LOW:HIGH);

examples/GarageDoor/README.md

@@ -13,7 +13,7 @@
       "maintainer": true
     }
   ],
-  "version": "2.2.2",
+  "version": "2.2.3",
   "frameworks": "arduino",
   "platforms": [
     "espressif8266",

examples/Switch/Switch.ino

@@ -1,5 +1,5 @@
 name=SinricPro
-version=2.2.2
+version=2.2.3
 author=Boris Jaeger <[email protected]>
 maintainer=Boris Jaeger <[email protected]>
 sentence=Library for https://sinric.pro - simple way to connect your device to alexa

library.json

@@ -44,7 +44,7 @@ unsigned long lastBtnPress = 0;
  * return
  *  true if request should be marked as handled correctly / false if not
  */
-bool onPowerState(String deviceId, bool &state) {
+bool onPowerState(const String &deviceId, bool &state) {
   Serial.printf("Device %s turned %s (via SinricPro) \r\n", deviceId.c_str(), state?"on":"off");
   myPowerState = state;
   digitalWrite(LED_BUILTIN, myPowerState?LOW:HIGH);

library.properties

@@ -0,0 +1,61 @@
+/*
+ *  Copyright (c) 2019 Sinric. All rights reserved.
+ *  Licensed under Creative Commons Attribution-Share Alike (CC BY-SA)
+ *
+ *  This file is part of the Sinric Pro (https://github.com/sinricpro/)
+ */
+
+
+#ifndef _LEAKY_BUCKET_H_
+#define _LEAKY_BUCKET_H_
+
+class LeakyBucket_t {
+  public:
+    LeakyBucket_t() : dropsInBucket(0), lastDrop(-DROP_IN_TIME), once(false) {}
+    bool addDrop();
+  private:
+    void leak();
+    int dropsInBucket;
+    unsigned long lastDrop;
+    bool once;
+    unsigned long lastWarning;
+};
+
+bool LeakyBucket_t::addDrop() {
+  leak();
+  unsigned long actualMillis = millis();
+
+  if (dropsInBucket < BUCKET_SIZE && actualMillis-lastDrop > dropsInBucket + DROP_IN_TIME) { // new drop can be placed into bucket?
+    dropsInBucket++;                                                                          // place drop in bucket
+    lastDrop = actualMillis;                                                                  // store last drop time
+    if (dropsInBucket == BUCKET_SIZE && once==false) {
+      Serial.printf("[SinricPro]: WARNING: YOU SENT TOO MUCH EVENTS IN A SHORT PERIOD OF TIME!\r\n  - PLEASE CHECK YOUR CODE AND SEND EVENTS ONLY IF DEVICE STATE HAS CHANGED!\r\n");      // Print a warning when bucket is full
+      once = true;
+    }
+    return true;
+  }
+
+  if (dropsInBucket >= BUCKET_SIZE) {
+    if (actualMillis-lastWarning > 1000) {
+      Serial.printf("[SinricPro]: EVENTS ARE BLOCKED FOR %lu SECONDS!\r\n",(DROP_OUT_TIME-(actualMillis-lastDrop))/1000);
+      lastWarning = actualMillis;
+    }
+  }
+  return false;
+}
+
+void LeakyBucket_t::leak() {
+// leack bucket...
+  unsigned long actualMillis = millis();
+  int drops_to_leak = (actualMillis - lastDrop) / DROP_OUT_TIME;
+  if (drops_to_leak > 0) {
+    if (dropsInBucket <= drops_to_leak) {
+      dropsInBucket = 0;
+    } else {
+      dropsInBucket -= drops_to_leak;
+    }
+  }
+}
+
+
+#endif

pio-examples/switch/src/switch.cpp

@@ -7,20 +7,37 @@
 
 #ifndef __SINRICPRO_CONFIG_H__
 #define __SINRICPRO_CONFIG_H__
+/* 
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * !!                                                 !!
+ * !!             WARNING: DON'T TOUCH !              !!
+ * !!             ======================              !!
+ * !! PLEASE DO NOT MODIFY ANY OF THESE SETTINGS HERE !!
+ * !!     THIS IS FOR INTERNAL CONFIGURATION ONLY     !!
+ * !!   SINRIC PRO MIGHT NOT WORK IF YOU MODIFY THIS  !!
+ * !!                                                 !!
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
 
-#define SDK_VERSION "2.2.2"
+// Version Configuration
+#define SDK_VERSION "2.2.3"
 
+// Server Configuration
 #define SINRICPRO_SERVER_URL "ws.sinric.pro"
 #define SINRICPRO_SERVER_PORT 80
 
+// UDP Configuration
 #define UDP_MULTICAST_IP IPAddress(224,9,9,9)
 #define UDP_MULTICAST_PORT 3333
 
-// websocket sends every WEBSOCKET_PING_INTERVAL milliseconds a ping to Server
-// if there is no pong received after WEBSOCKET_PING_TIMEOUT milliseconds, retry count is incremented by one
-// if retry count reaches WEBSOCKET_RETRY_COUNT websocket connection is closed and try to reconnect server
+// WebSocket Configuration
 #define WEBSOCKET_PING_INTERVAL 300000
 #define WEBSOCKET_PING_TIMEOUT 10000
 #define WEBSOCKET_RETRY_COUNT 2
 
+// LeakyBucket Configuration
+#define BUCKET_SIZE 10
+#define DROP_OUT_TIME 60000
+#define DROP_IN_TIME 1000u
+
 #endif

src/LeakyBucket.h

@@ -9,6 +9,8 @@
 #define _SINRICDEVICE_H_
 
 #include "SinricProDeviceInterface.h"
+#include "LeakyBucket.h"
+
 #include <map>
 
 class SinricProDevice : public SinricProDeviceInterface {
@@ -23,7 +25,7 @@ class SinricProDevice : public SinricProDeviceInterface {
     virtual bool handleRequest(const char* deviceId, const char* action, JsonObject &request_value, JsonObject &response_value);
 
     // standard callbacks
-	  typedef std::function<bool(const String, bool&)> PowerStateCallback;
+	  typedef std::function<bool(const String&, bool&)> PowerStateCallback;
     virtual void onPowerState(PowerStateCallback cb) { powerStateCallback = cb; }
 
     // standard events
@@ -37,7 +39,7 @@ class SinricProDevice : public SinricProDeviceInterface {
   private:
     SinricProInterface* eventSender;
     unsigned long eventWaitTime;
-    std::map<String, unsigned long> eventFilter;
+    std::map<String, LeakyBucket_t> eventFilter;
 };
 
 SinricProDevice::SinricProDevice(const char* newDeviceId, unsigned long eventWaitTime) : 
@@ -81,22 +83,30 @@ DynamicJsonDocument SinricProDevice::prepareEvent(const char* deviceId, const ch
   return DynamicJsonDocument(1024);
 }
 
+
 bool SinricProDevice::sendEvent(JsonDocument& event) {
-  unsigned long actualMillis = millis();
   String eventName = event["payload"]["action"] | ""; // get event name
 
-  if (eventFilter.find(eventName) == eventFilter.end()) {  // if eventFilter is not initialized
-    eventFilter[eventName] = -eventWaitTime; // initialize eventFilter
+  LeakyBucket_t bucket; // leaky bucket algorithm is used to prevent flooding the server
+
+  // get leaky bucket for event from eventFilter
+  if (eventFilter.find(eventName) == eventFilter.end()) {  // if there is no bucket ...
+    eventFilter[eventName] = bucket;                       // ...add a new bucket
+  } else {  
+    bucket = eventFilter[eventName];                       // else get bucket
   }
 
-  unsigned long lastEventMillis = eventFilter[eventName] | 0; // get the last timestamp for event
-  if (actualMillis - lastEventMillis < eventWaitTime) return false; // if last event was before waitTime return...
+  if (bucket.addDrop()) {                                  // if we can add a new drop
+    if (eventSender) eventSender->sendMessage(event);      // send event
+    eventFilter[eventName] = bucket;                       // update bucket on eventFilter
+    return true;
+  }
 
-  if (eventSender) eventSender->sendMessage(event); // send event
-  eventFilter[eventName] = actualMillis; // update lastEventTime
-  return true;
+  eventFilter[eventName] = bucket;                        // update bucket on eventFilter
+  return false;
 }
 
+
 bool SinricProDevice::sendPowerStateEvent(bool state, String cause) {
   DynamicJsonDocument eventMessage = prepareEvent(deviceId, "setPowerState", cause.c_str());
   JsonObject event_value = eventMessage["payload"]["value"];