before ctl

src/din/buz.h

@@ -2,7 +2,7 @@
  * @Author: IoTcat (https://iotcat.me) 
  * @Date: 2019-08-20 09:58:28 
  * @Last Modified by: 
- * @Last Modified time: 2019-08-20 10:07:51
+ * @Last Modified time: 2019-08-30 12:35:44
  */
 #ifndef __BUZ_H__
 #define __BUZ_H__
@@ -14,15 +14,18 @@ class Buz{
     };
     ~Buz(){};
 
-    void ini() const{
+    void ini() {
         pinMode(this->_pin, OUTPUT);
+        this->_fStatus = this->getStatus();
     };
 
-    void loop() const{
+    void loop(){
         if(millis() < this->_toT){
             analogWrite(this->_pin, (int)((float)((this->_toT - millis()) % 3000) * 255 / 3000));
+            this->_status = true;
         }else{
             analogWrite(this->_pin, 0);
+            this->_status = false;
         }
     };
 
@@ -38,9 +41,23 @@ class Buz{
         this->_toT = millis() + 3000 * times;
     }
 
+    inline const bool getStatus() const{
+        return this->_status;
+    }
+
+    inline const bool isStateChange() {
+        if(this->_fStatus != this->getStatus()){
+            this->_fStatus = this->getStatus();
+            return true;
+        }else{
+            return false;
+        }
+    }
+
     private:
     static unsigned int _toT;
     unsigned int _pin; 
+    bool _status, _fStatus;
 };
 
 unsigned int Buz::_toT = 0;

src/din/din.ino

@@ -2,7 +2,7 @@
  * @Author: IoTcat (https://iotcat.me) 
  * @Date: 2019-08-20 09:57:58 
  * @Last Modified by: 
- * @Last Modified time: 2019-08-20 11:11:31
+ * @Last Modified time: 2019-08-30 14:21:56
  */
 
 #include <PubSubClient.h>
@@ -12,25 +12,30 @@
 #include "buz.h"
 #include "swi.h"
 #include "pir.h"
+#include "relay.h"
+#include "mode.h"
+#include "lightCtl.h"
 
 const char* ssid = "yimian-iot";
 const char* password = "1234567890.";
 const char* mqtt_server = "192.168.3.4";  // change this to the mqtt server
 
 const char* topicInCtl = "hass/ctl/din/#";  // change this to the outgoing messages
-const char* topicInSnsr = "hass/snsr/livb/#";
-const char* topicInSnsr1 = "hass/snsr/hall/#";
+const char* topicInRefresh = "hass/refresh";
 
 const String clientId = "din";
-
+const unsigned short pirNum = 4;
 
 WiFiClient espClient;
 PubSubClient client(espClient);
 
 Buz buz(D8);
 Swi swi(D1, D2);
-Pir p0(D6), p1(D13), p2(D11), p3(D12);
+Pir p[pirNum] = {D6, D13, D11, D12};
 LED led(D0);
+Relay light(D5);
+Mode mode;
+LightCtl lightCtl(&light, &led, &mode);
 
 void setup() {
     Serial.begin(115200);
@@ -48,19 +53,22 @@ void setup() {
     client.setServer(mqtt_server, 1883);  // default port, change it...
     client.setCallback(callback);
 
-    swi.on("on", swiOn);
-    swi.on("off", swiOff);
+    swi.on("toggle", swiToggle);
+
 
     buz.ini();
     swi.ini();
-    p0.ini();
-    p1.ini();
-    p2.ini();
-    p3.ini();
+    for(auto i : p){
+        i.ini();
+    }
     led.ini();
+    light.ini();
+    mode.ini();
 
 }
 
+
+
 void callback(char* topic, byte* payload, unsigned int length) {
     Serial.print("Message arrived [");
     Serial.print(topic);
@@ -72,33 +80,28 @@ void callback(char* topic, byte* payload, unsigned int length) {
     Serial.print(s);
     Serial.println("");
 
-    if(topic == "")
-
-    if(s=="1"){
-      buz.once();
-    }else{
-      buz.off();
-    }
-    client.publish("hass/snsr/liv/light", s.c_str(), 1);
-    client.publish("hass/snsr/livd/test", String(analogRead(A0)).c_str());
+    mqtt_refresh(topic, s);
+    mqtt_mode(topic, s);
+    mqtt_lightCtl(topic, s);
+    mqtt_buz(topic, s);
 
-    Serial.println(String(analogRead(A0)).c_str());
 }
 
 void reconnect() {
     // Loop until we're reconnected
     while (!client.connected()) {
+        mode.isOffline(true);
         Serial.print("Attempting MQTT connection...");
 
         // Attempt to connect
         if (client.connect(clientId.c_str())) {
             Serial.println("connected");
+            mode.isOffline(false);
             // Once connected, publish an announcement...
             // client.publish(topicOut, "Hello from the Gateway!");
             // ... and resubscribe
             client.subscribe(topicInCtl);
-            client.subscribe(topicInSnsr);
-            client.subscribe(topicInSnsr1);
+            client.subscribe(topicInRefresh);
         } else {
             Serial.print("failed, rc=");
             Serial.print(client.state());
@@ -109,31 +112,154 @@ void reconnect() {
     }
 }
 
-void swiOn(){
-    Serial.println("onononon");  
-}
 
-void swiOff(){
-  
-  Serial.println("offoffoff");  
-}
+
+
 
 void loop() {
+
+    // mqtt core
     if (!client.connected()) {
         reconnect();
     }
     client.loop();
 
+    // component core
     buz.loop();
     swi.loop();
-    p.loop();
 
-    if(p.isPeopleIn()){
-      Serial.println("ppppppin");
+    // pir snsr
+    for(unsigned short i = 0; i < pirNum; i ++){
+        p[i].loop();
+        if(p[i].isPeopleIn()){
+            client.publish(String("hass/snsr/"+clientId+"/p"+i).c_str(), "1");
+        }
+        if(p[i].isPeopleOut()){
+            client.publish(String("hass/snsr/"+clientId+"/p"+i).c_str(), "0");
+        }
+    }
+
+    // lightCtl trigger
+    if(lightCtl.isStateChange()){
+        client.publish(String("hass/snsr/"+clientId+"/lightCtl").c_str(), String(lightCtl.getStatus()).c_str());
+    }
+    // light trigger
+    if(light.isStateChange()){
+        client.publish(String("hass/snsr/"+clientId+"/light").c_str(), String(light.getStatus()).c_str());
+    }
+   // buz trigger
+   if(buz.isStateChange()){
+        client.publish(String("hass/snsr/"+clientId+"/buz").c_str(), String(buz.getStatus()).c_str());
+   } 
+    // led trigger
+    if(led.isStateChange()){
+        client.publish(String("hass/snsr/"+clientId+"/led").c_str(), led.getMode().c_str());
+    }
+    // mode trigger
+    if(mode.isNightChange()){
+        client.publish(String("hass/snsr/"+clientId+"/mode/isNight").c_str(), String(mode.isNight()).c_str());
+    } 
+    if(mode.isAutoChange()){
+        client.publish(String("hass/snsr/"+clientId+"/mode/isAuto").c_str(), String(mode.isAuto()).c_str());
+    }
+    if(mode.isMidnight()){
+        client.publish(String("hass/snsr/"+clientId+"/mode/isMidnight").c_str(), String(mode.isMidnight()).c_str());
+    }
+    if(mode.isOfflineChange()){
+        client.publish(String("hass/snsr/"+clientId+"/mode/isOffline").c_str(), String(mode.isOffline()).c_str());
     }
 
-    if(p.isPeopleOut()){
-      Serial.println("pppppppout");
-      }
 }
 
+
+/**** mqtt func ****/
+
+void mqtt_refresh(const String& subject, const String& content){
+
+    // send all status
+    if(subject == topicInRefresh){
+        client.publish(String("hass/snsr/"+clientId+"/lightCtl").c_str(), String(lightCtl.getStatus()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/mode/isNight").c_str(), String(mode.isNight()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/mode/isAuto").c_str(), String(mode.isAuto()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/mode/isMidnight").c_str(), String(mode.isMidnight()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/mode/isOffline").c_str(), String(mode.isOffline()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/light").c_str(), String(light.getStatus()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/buz").c_str(), String(buz.getStatus()).c_str());
+        client.publish(String("hass/snsr/"+clientId+"/swi").c_str(), String(swi.state()).c_str());
+        for(unsigned short i = 0; i < pirNum; i ++){
+            client.publish(String("hass/snsr/"+clientId+"/p"+i).c_str(), String(p[i].getState()).c_str());
+        }
+        client.publish(String("hass/snsr/"+clientId+"/led").c_str(), led.getMode().c_str());
+    }
+
+}
+
+void mqtt_mode(const String& subject, const String& content){
+
+    if(subject == String("hass/ctl/"+clientId+"/mode/isNight")){
+        if(content == "0"){
+            mode.isNight(false);
+        }
+        if(content == "1"){
+            mode.isNight(true);
+        }
+    }
+    if(subject == String("hass/ctl/"+clientId+"/mode/isAuto")){
+        if(content == "0"){
+            mode.isAuto(false);
+        }
+        if(content == "1"){
+            mode.isAuto(true);
+        }
+    }
+    if(subject == String("hass/ctl/"+clientId+"/mode/isMidnight")){
+        if(content == "0"){
+            mode.isMidnight(false);
+        }
+        if(content == "1"){
+            mode.isMidnight(true);
+        }
+    }
+    if(subject == String("hass/ctl/"+clientId+"/mode/isOffline")){
+        if(content == "0"){
+            mode.isOffline(false);
+        }
+        if(content == "1"){
+            mode.isOffline(true);
+        }
+    }
+
+}
+
+void mqtt_lightCtl(const String& subject, const String& content){
+    if(subject == String("hass/ctl/"+clientId+"/lightCtl")){
+        if(content == "0"){
+            lightCtl.off();
+        }
+        if(content == "1"){
+            lightCtl.on();
+        }
+    }
+}
+
+void mqtt_buz(const String& subject, const String& content){
+    if(subject == String("hass/ctl/"+clientId+"/buz")){
+        if(content == "0"){
+            buz.off();
+        }
+        if(content == "1"){
+            buz.on();
+        }
+    }
+}
+
+
+/**** swi ****/
+void swiToggle(){
+    client.publish(String("hass/snsr/"+clientId+"/swi").c_str(), String(swi.state()).c_str());
+
+}
+
+
+
+/**** lightCtl ****/

src/din/led.h

@@ -2,7 +2,7 @@
  * @Author: IoTcat (https://iotcat.me) 
  * @Date: 2019-08-20 09:58:21 
  * @Last Modified by: 
- * @Last Modified time: 2019-08-20 10:00:02
+ * @Last Modified time: 2019-08-30 13:12:01
  */
 #ifndef __LED_H__
 #define __LED_H__
@@ -12,32 +12,33 @@ class LED {
 
     LED(const int& pin){
         this->_pin = pin;
-        this->_mode = "null";
+        this->_mode = "on";
     };
     ~LED(){};
 
     inline void on(){
         digitalWrite(this->_pin, HIGH);
-        this->_mode = "null";
+        this->_mode = "on";
     }
 
     inline void off(){
         digitalWrite(this->_pin, LOW);
-        this->_mode = "null";
+        this->_mode = "off";
     }
 
     inline const bool toggle(){
         digitalWrite(this->_pin, !digitalRead(this->_pin));
-        this->_mode = "null";
+        this->_mode = (digitalRead(this->_pin)) ? "on" : "off";
         return digitalRead(this->_pin);
     }
 
-    inline void ini() const{
+    inline void ini(){
         pinMode(this->_pin, OUTPUT);
+        this->_fStatus = this->getMode();
     }
 
     inline void loop() const{
-        if(this->_mode == "null"){
+        if(this->_mode == "on" || this->_mode == "off"){
             return;
         }
 
@@ -73,11 +74,24 @@ class LED {
         this->_period = period;
     }
 
+    inline const String getMode() const{
+        return this->_mode;
+    }
+
+    inline const bool isStateChange(){
+        if(this->_fStatus != this->getMode()){
+            this->_fStatus = this->getMode();
+            return true;
+        }else{
+            return false;
+        }
+    }
+
    private:
    unsigned short _pin;
-   String _mode;
+   String _mode, _fStatus;
    unsigned int _period;
 
 };
 
-#endif  //__LED_H__
+#endif  //__LED_H__

src/din/lightCtl.h

@@ -0,0 +1,107 @@
+/*
+ * @Author: IoTcat (https://iotcat.me) 
+ * @Date: 2019-08-30 13:36:43 
+ * @Last Modified by: 
+ * @Last Modified time: 2019-08-30 14:17:59
+ */
+
+#ifndef __LIGHTCTL_H__
+#define __LIGHTCTL_H__
+
+class LightCtl{
+public:
+    LightCtl(Relay* _light, LED* _led, Mode* _mode){
+        light = _light;
+        led = _led;
+        mode = _mode;
+        _fStatus = _status;
+    };
+    ~LightCtl(){
+       delete light, led, mode;
+     };
+
+    void on(){
+        if(mode->isOffline()){
+            if(mode->nightMode() == 0){
+                light->off();
+                led->star();
+            }
+            if(mode->nightMode() == 1){
+                light->on();
+                led->star();
+            }
+            if(mode->nightMode() == 2){
+                light->off();
+                led->on();
+            }
+        }else{
+            if(mode->nightMode() == 0){
+                light->off();
+                led->breath();
+            }
+            if(mode->nightMode() == 1){
+                light->on();
+                led->breath();
+            }
+            if(mode->nightMode() == 2){
+                light->off();
+                led->on();
+            }
+        }
+        _status = true;
+    }
+    void off(){
+        if(mode->isOffline()){
+            if(mode->nightMode() == 0){
+                light->off();
+                led->star();
+            }
+            if(mode->nightMode() == 1){
+                light->off();
+                led->star();
+            }
+            if(mode->nightMode() == 2){
+                light->off();
+                led->star();
+            }
+        }else{
+            light->off();
+            led->off();
+        }
+        _status = false;
+    }
+
+    inline const bool toggle(){
+        if(_status){
+            off();
+        }else{
+            on();
+        }
+        return _status;
+    }
+
+    inline const bool isStateChange(){
+        if(_fStatus != _status){
+            _fStatus = _status;
+            return true;
+        }
+        return false;
+    }
+
+    inline const bool getStatus(){
+        return _status;
+    }
+
+private:
+    Relay* light;
+    LED* led;
+    Mode* mode;
+    bool _status, _fStatus;
+
+};
+
+
+
+
+
+#endif //__LIGHTCTL_H__

src/din/mode.h

@@ -0,0 +1,115 @@
+/*
+ * @Author: IoTcat (https://iotcat.me) 
+ * @Date: 2019-08-30 11:14:59 
+ * @Last Modified by: 
+ * @Last Modified time: 2019-08-30 13:31:16
+ */
+
+#ifndef __MODE_H__
+#define __MODE_H__
+
+class Mode{
+public:
+    Mode() : _isNight(false), _fIsNight(false), _isAuto(true), _fIsAuto(true), \
+    _isMidnight(false), _fIsMidnight(false), _isOffline(true), _fIsOffline(true){};
+    ~Mode(){};
+
+    inline void ini() const{
+    }
+    inline void begin() const{
+        this->ini();
+    }
+
+    inline void core() const{};
+    inline void loop() const{
+        this->core();
+    };
+
+    inline const bool isNight() const{
+        return this->_isNight;
+    }
+    inline const bool isNight(const bool& state){
+        this->_isNight = state;
+        return this->isNight();
+    }
+    inline const bool isNightChange(){
+        if(this->_isNight != this->_fIsNight){
+            this->_fIsNight = this->_isNight;
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    inline const bool isAuto() const{
+        return this->_isAuto;
+    }
+    inline const bool isAuto(const bool& state){
+        this->_isAuto = state;
+        return this->isAuto();
+    }
+    inline const bool isAutoChange(){
+        if(this->_isAuto != this->_fIsAuto){
+            this->_fIsAuto = this->_isAuto;
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    inline const bool isMidnight() const{
+        return this->_isMidnight;
+    }
+    inline const bool isMidnight(const bool& state){
+        this->_isMidnight = state;
+        return this->isMidnight();
+    }
+    inline const bool isMidnightChange(){
+        if(this->_isMidnight != this->_fIsMidnight){
+            this->_fIsMidnight = this->_isMidnight;
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    inline const bool isOffline() const{
+        return this->_isOffline;
+    }
+    inline const bool isOffline(const bool& state){
+        this->_isOffline = state;
+        return this->isOffline();
+    }
+    inline const bool isOfflineChange(){
+        if(this->_isOffline != this->_fIsOffline){
+            this->_fIsOffline = this->_isOffline;
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    inline const unsigned short nightMode(){
+        if(!this->isNight() && !this->isMidnight()){
+            return 0;
+        }
+        if(this->isNight() && !this->isMidnight()){
+            return 1;
+        }
+        if(this->isMidnight()){
+            return 2;
+        }
+        return 0;
+    }
+
+
+private:
+    bool _isNight, _isAuto, _isMidnight, _isOffline;
+    bool _fIsNight, _fIsAuto, _fIsMidnight, _fIsOffline;
+    
+
+};
+
+
+
+#endif //__MODE_H__

src/din/relay.h

@@ -2,7 +2,7 @@
  * @Author: IoTcat (https://iotcat.me) 
  * @Date: 2019-08-30 11:00:00 
  * @Last Modified by: 
- * @Last Modified time: 2019-08-30 11:13:18
+ * @Last Modified time: 2019-08-30 12:35:33
  */
 
 #ifndef __RELAY_H__
@@ -16,10 +16,11 @@ public:
     };
     ~Relay(){};
 
-    inline void ini() const{
+    inline void ini() {
         pinMode(this->_pin, OUTPUT);
+        this->_fStatus = this->getStatus();
     };
-    inline void begin() const{
+    inline void begin() {
         this->ini();
     };
     inline void core() const{};
@@ -41,12 +42,21 @@ public:
         return (digitalRead(this->_pin) == this->_onStatus) ? true : false;
     }
 
+    inline const bool isStateChange() {
+        if(this->getStatus() != this->_fStatus){
+            this->_fStatus = this->getStatus();
+            return true;
+        }else{
+            return false;
+        }
+    }
+
 private:
     unsigned short _pin;
-    bool _onStatus;
+    bool _onStatus, _fStatus;
 
 };
 
 
 
-#endif //__RELAY_H__
+#endif //__RELAY_H__