base_drycontact.yaml

@@ -87,10 +87,11 @@ binary_sensor:
     entity_category: diagnostic
     filters:
       - delayed_on_off: 500ms
-    on_state:
-      then:
-        lambda: |-
-          id($id_prefix)->set_open_limit(x);
+    # on_state:
+    #   then:
+    #     lambda: |-
+    #       id($id_prefix)->call_protocol(set_open_limit { static_cast<bool>(true) });
+
   - platform: gpio
     id: "${id_prefix}_dry_contact_close"
     pin:
@@ -103,10 +104,12 @@ binary_sensor:
     entity_category: diagnostic
     filters:
       - delayed_on_off: 500ms
-    on_state:
-      then:
-        lambda: |-
-          id($id_prefix)->set_close_limit(x);
+    # on_press:
+    #   - if:
+    #       condition:
+    #         binary_sensor.is_off: ${id_prefix}_dry_contact_open
+    #       then:
+    #         - cover.close: ${id_prefix}_garage_door
   - platform: gpio
     id: "${id_prefix}_dry_contact_light"
     pin:
@@ -202,7 +205,7 @@ button:
 
   - platform: template
     id: ${id_prefix}_toggle_door
-    name: "Toggle door"
+    name: "Toggle door!"
     on_press:
       then:
         lambda: !lambda |-

components/ratgdo/dry_contact.cpp

@@ -23,7 +23,6 @@ namespace ratgdo {
             this->last_open_limit_ = 0;
             this->close_limit_reached_ = 0;
             this->last_close_limit_ = 0;
-            this->door_state_ = DoorState::UNKNOWN;
         }
 
         void DryContact::loop()
@@ -37,43 +36,42 @@ namespace ratgdo {
 
         void DryContact::sync()
         {
-            ESP_LOG1(TAG, "Ignoring sync action");
         }
 
-        void DryContact::set_open_limit(bool state)
+        void DryContact::set_open_limit(bool val)
         {
-            ESP_LOGD(TAG, "Set open_limit_reached to %d", state);
+            ESP_LOGD(TAG, "Set open_limit_reached to %d", val);
             this->last_open_limit_ = this->open_limit_reached_;
-            this->last_close_limit_ = false;
-            this->open_limit_reached_ = state;
+            this->open_limit_reached_ = val;
             this->send_door_state();
         }
 
-        void DryContact::set_close_limit(bool state)
+        void DryContact::set_close_limit(bool val)
         {
-            ESP_LOGD(TAG, "Set close_limit_reached to %d", state);
+            ESP_LOGD(TAG, "Set close_limit_reached to %d", val);
             this->last_close_limit_ = this->close_limit_reached_;
-            this->last_open_limit_ = false;
-            this->close_limit_reached_ = state;
+            this->close_limit_reached_ = val;
             this->send_door_state();
         }
         
         void DryContact::send_door_state(){
+            DoorState door_state;
+
             if(this->open_limit_reached_){
-                this->door_state_ = DoorState::OPEN;
+                door_state = DoorState::OPEN;
             }else if(this->close_limit_reached_){
-                this->door_state_ = DoorState::CLOSED;
+                door_state = DoorState::CLOSED;
             }else if(!this->close_limit_reached_ && !this->open_limit_reached_){
                 if(this->last_close_limit_){
-                    this->door_state_ = DoorState::OPENING;
+                    door_state = DoorState::OPENING;
                 }
 
                 if(this->last_open_limit_){
-                    this->door_state_ = DoorState::CLOSING;
+                    door_state = DoorState::CLOSING;
                 }
             }
 
-            this->ratgdo_->received(this->door_state_);
+            this->ratgdo_->received(door_state);
         }
 
         void DryContact::light_action(LightAction action)
@@ -90,19 +88,14 @@ namespace ratgdo {
 
         void DryContact::door_action(DoorAction action)
         {
-            if (action == DoorAction::OPEN && this->door_state_ != DoorState::CLOSED) {
-                ESP_LOGW(TAG, "The door is not closed. Ignoring door action: %s", DoorAction_to_string(action));
+            if (action != DoorAction::TOGGLE) {
+                ESP_LOG1(TAG, "Ignoring door action: %s", DoorAction_to_string(action));
                 return;
             }
-            if (action == DoorAction::CLOSE && this->door_state_ != DoorState::OPEN) {
-                ESP_LOGW(TAG, "The door is not open. Ignoring door action: %s", DoorAction_to_string(action));
-                return;
-            }
-
             ESP_LOG1(TAG, "Door action: %s", DoorAction_to_string(action));
 
             this->tx_pin_->digital_write(1);
-            this->scheduler_->set_timeout(this->ratgdo_, "", 500, [=] {
+            this->scheduler_->set_timeout(this->ratgdo_, "", 200, [=] {
                 this->tx_pin_->digital_write(0);
             });
         }

components/ratgdo/dry_contact.h

@@ -29,8 +29,8 @@ namespace ratgdo {
             void light_action(LightAction action);
             void lock_action(LockAction action);
             void door_action(DoorAction action);
-            void set_open_limit(bool state);
-            void set_close_limit(bool state);
+            void set_open_limit(bool val);
+            void set_close_limit(bool val);
             void send_door_state();
 
             Result call(Args args);
@@ -46,7 +46,6 @@ namespace ratgdo {
             RATGDOComponent* ratgdo_;
             Scheduler* scheduler_;
 
-            DoorState door_state_;
             bool open_limit_reached_;
             bool last_open_limit_;
             bool close_limit_reached_;

components/ratgdo/protocol.h

@@ -102,8 +102,6 @@ namespace ratgdo {
             virtual void dump_config();
 
             virtual void sync();
-            virtual void set_open_limit(bool);
-            virtual void set_close_limit(bool);
 
             virtual const Traits& traits() const;
 

components/ratgdo/ratgdo.cpp

@@ -420,16 +420,6 @@ namespace ratgdo {
         this->protocol_->sync();
     }
 
-    void RATGDOComponent::set_open_limit(bool state)
-    {
-        this->protocol_->set_open_limit(state);
-    }
-
-    void RATGDOComponent::set_close_limit(bool state)
-    {
-        this->protocol_->set_close_limit(state);
-    }
-
     void RATGDOComponent::door_open()
     {
         if (*this->door_state == DoorState::OPENING) {

components/ratgdo/ratgdo.h

@@ -145,8 +145,6 @@ namespace ratgdo {
         void query_status();
         void query_openings();
         void sync();
-        void set_open_limit(bool);
-        void set_close_limit(bool);
 
         // children subscriptions
         void subscribe_rolling_code_counter(std::function<void(uint32_t)>&& f);