Merge 034125d3fc into b148105423

* Auto detect obstruction sensors
* Use toggle action instead of close if no sensors detected
* Toggle for close only when door is open

.pre-commit-config.yaml

@@ -7,3 +7,12 @@ repos:
     -   id: trailing-whitespace
     -   id: end-of-file-fixer
     -   id: check-added-large-files
+- repo: https://github.com/pre-commit/mirrors-clang-format
+  rev: v18.1.8
+  hooks:
+  - id: clang-format
+    types_or:
+     - "c++"
+     - "c"
+     - "cuda"
+    args: [-style=Webkit, -i]

components/ratgdo/dry_contact.cpp

@@ -1,11 +1,12 @@
 
-#include "dry_contact.h"
 #include "ratgdo.h"
 
+#ifdef PROTOCOL_DRYCONTACT
+
+#include "dry_contact.h"
 #include "esphome/core/gpio.h"
 #include "esphome/core/log.h"
 #include "esphome/core/scheduler.h"
-#include "esphome/components/gpio/binary_sensor/gpio_binary_sensor.h"
 
 namespace esphome {
 namespace ratgdo {
@@ -59,17 +60,18 @@ namespace ratgdo {
             this->send_door_state();
         }
 
-        void DryContact::send_door_state(){
-            if(this->open_limit_reached_){
+        void DryContact::send_door_state()
+        {
+            if (this->open_limit_reached_) {
                 this->door_state_ = DoorState::OPEN;
-            }else if(this->close_limit_reached_){
+            } else if (this->close_limit_reached_) {
                 this->door_state_ = DoorState::CLOSED;
-            }else if(!this->close_limit_reached_ && !this->open_limit_reached_){
-                if(this->last_close_limit_){
+            } else if (!this->close_limit_reached_ && !this->open_limit_reached_) {
+                if (this->last_close_limit_) {
                     this->door_state_ = DoorState::OPENING;
                 }
 
-                if(this->last_open_limit_){
+                if (this->last_open_limit_) {
                     this->door_state_ = DoorState::CLOSING;
                 }
             }
@@ -102,14 +104,14 @@ namespace ratgdo {
 
             ESP_LOG1(TAG, "Door action: %s", DoorAction_to_string(action));
 
-            if (action == DoorAction::OPEN){
+            if (action == DoorAction::OPEN) {
                 this->discrete_open_pin_->digital_write(1);
                 this->scheduler_->set_timeout(this->ratgdo_, "", 500, [=] {
                     this->discrete_open_pin_->digital_write(0);
                 });
             }
 
-            if (action == DoorAction::CLOSE){
+            if (action == DoorAction::CLOSE) {
                 this->discrete_close_pin_->digital_write(1);
                 this->scheduler_->set_timeout(this->ratgdo_, "", 500, [=] {
                     this->discrete_close_pin_->digital_write(0);
@@ -127,6 +129,8 @@ namespace ratgdo {
             return {};
         }
 
-    } // namespace DryContact
+    } // namespace dry_contact
 } // namespace ratgdo
 } // namespace esphome
+
+#endif

components/ratgdo/dry_contact.h

@@ -1,9 +1,12 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+
+#ifdef PROTOCOL_DRYCONTACT
+
 #include "SoftwareSerial.h" // Using espsoftwareserial https://github.com/plerup/espsoftwareserial
-#include "esphome/core/optional.h"
 #include "esphome/core/gpio.h"
-#include "esphome/components/gpio/binary_sensor/gpio_binary_sensor.h"
+#include "esphome/core/optional.h"
 
 #include "callbacks.h"
 #include "observable.h"
@@ -36,13 +39,15 @@ namespace ratgdo {
             void set_close_limit(bool state);
             void send_door_state();
 
-            void set_discrete_open_pin(InternalGPIOPin* pin) { 
+            void set_discrete_open_pin(InternalGPIOPin* pin)
+            {
                 this->discrete_open_pin_ = pin;
                 this->discrete_open_pin_->setup();
                 this->discrete_open_pin_->pin_mode(gpio::FLAG_OUTPUT);
             }
 
-            void set_discrete_close_pin(InternalGPIOPin* pin) {
+            void set_discrete_close_pin(InternalGPIOPin* pin)
+            {
                 this->discrete_close_pin_ = pin;
                 this->discrete_close_pin_->setup();
                 this->discrete_close_pin_->pin_mode(gpio::FLAG_OUTPUT);
@@ -68,9 +73,10 @@ namespace ratgdo {
             bool last_open_limit_;
             bool close_limit_reached_;
             bool last_close_limit_;
-
         };
 
-    } // namespace secplus1
+    } // namespace dry_contact
 } // namespace ratgdo
 } // namespace esphome
+
+#endif

components/ratgdo/ratgdo.cpp

@@ -38,15 +38,9 @@ namespace ratgdo {
         this->input_gdo_pin_->setup();
         this->input_gdo_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
 
-        if (this->input_obst_pin_ == nullptr) {
-            // Our base.yaml is always going to set this so we check for 0
-            // as well to avoid a breaking change.
-            this->obstruction_from_status_ = true;
-        } else {
         this->input_obst_pin_->setup();
         this->input_obst_pin_->pin_mode(gpio::FLAG_INPUT);
         this->input_obst_pin_->attach_interrupt(RATGDOStore::isr_obstruction, &this->isr_store_, gpio::INTERRUPT_FALLING_EDGE);
-        }
 
         this->protocol_->setup(this, &App.scheduler, this->input_gdo_pin_, this->output_gdo_pin_);
 
@@ -76,9 +70,7 @@ namespace ratgdo {
 
     void RATGDOComponent::loop()
     {
-        if (!this->obstruction_from_status_) {
         this->obstruction_loop();
-        }
         this->protocol_->loop();
     }
 
@@ -87,11 +79,7 @@ namespace ratgdo {
         ESP_LOGCONFIG(TAG, "Setting up RATGDO...");
         LOG_PIN("  Output GDO Pin: ", this->output_gdo_pin_);
         LOG_PIN("  Input GDO Pin: ", this->input_gdo_pin_);
-        if (this->obstruction_from_status_) {
-            ESP_LOGCONFIG(TAG, "  Input Obstruction Pin: not used, will detect from GDO status");
-        } else {
         LOG_PIN("  Input Obstruction Pin: ", this->input_obst_pin_);
-        }
         this->protocol_->dump_config();
     }
 
@@ -218,7 +206,7 @@ namespace ratgdo {
 
     void RATGDOComponent::received(const ObstructionState obstruction_state)
     {
-        if (this->obstruction_from_status_) {
+        if (!this->obstruction_sensor_detected_) {
             ESP_LOGD(TAG, "Obstruction: state=%s", ObstructionState_to_string(*this->obstruction_state));
 
             this->obstruction_state = obstruction_state;
@@ -378,6 +366,7 @@ namespace ratgdo {
             // check to see if we got more then PULSES_LOWER_LIMIT pulses
             if (this->isr_store_.obstruction_low_count > PULSES_LOWER_LIMIT) {
                 this->obstruction_state = ObstructionState::CLEAR;
+                this->obstruction_sensor_detected_ = true;
             } else if (this->isr_store_.obstruction_low_count == 0) {
                 // if there have been no pulses the line is steady high or low
                 if (!this->input_obst_pin_->digital_read()) {
@@ -471,7 +460,12 @@ namespace ratgdo {
             return;
         }
 
+        if (this->obstruction_sensor_detected_) {
             this->door_action(DoorAction::CLOSE);
+        } else if (*this->door_state == DoorState::OPEN) {
+            ESP_LOGD(TAG, "No obstruction sensors detected. Close using TOGGLE.");
+            this->door_action(DoorAction::TOGGLE);
+        }
 
         if (*this->closing_duration > 0) {
             // query state in case we don't get a status message
@@ -686,26 +680,24 @@ namespace ratgdo {
         this->learn_state.subscribe([=](LearnState state) { defer("learn_state", [=] { f(state); }); });
     }
 
+#ifdef PROTOCOL_DRYCONTACT
     // dry contact methods
-    void RATGDOComponent::set_dry_contact_open_sensor(esphome::gpio::GPIOBinarySensor* dry_contact_open_sensor)
+    void RATGDOComponent::set_dry_contact_open_sensor(esphome::binary_sensor::BinarySensor* dry_contact_open_sensor)
     {
         dry_contact_open_sensor_ = dry_contact_open_sensor;
-        dry_contact_open_sensor_->add_on_state_callback([this](bool sensor_value)
-        {
+        dry_contact_open_sensor_->add_on_state_callback([this](bool sensor_value) {
             this->protocol_->set_open_limit(sensor_value);
-        }
-        );
+        });
     }
 
-    void RATGDOComponent::set_dry_contact_close_sensor(esphome::gpio::GPIOBinarySensor* dry_contact_close_sensor)
+    void RATGDOComponent::set_dry_contact_close_sensor(esphome::binary_sensor::BinarySensor* dry_contact_close_sensor)
     {
         dry_contact_close_sensor_ = dry_contact_close_sensor;
-        dry_contact_close_sensor_->add_on_state_callback([this](bool sensor_value)
-        {
+        dry_contact_close_sensor_->add_on_state_callback([this](bool sensor_value) {
             this->protocol_->set_close_limit(sensor_value);
+        });
     }
-        );
-    }
+#endif
 
 } // namespace ratgdo
 } // namespace esphome

components/ratgdo/ratgdo.h

@@ -14,9 +14,12 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/preferences.h"
-#include "esphome/components/gpio/binary_sensor/gpio_binary_sensor.h"
+#ifdef PROTOCOL_DRYCONTACT
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
 
 #include "callbacks.h"
 #include "macros.h"
@@ -92,11 +95,13 @@ namespace ratgdo {
         void set_input_gdo_pin(InternalGPIOPin* pin) { this->input_gdo_pin_ = pin; }
         void set_input_obst_pin(InternalGPIOPin* pin) { this->input_obst_pin_ = pin; }
 
+#ifdef PROTOCOL_DRYCONTACT
         // dry contact methods
-        void set_dry_contact_open_sensor(esphome::gpio::GPIOBinarySensor* dry_contact_open_sensor_);
-        void set_dry_contact_close_sensor(esphome::gpio::GPIOBinarySensor* dry_contact_close_sensor_);
-        void set_discrete_open_pin(InternalGPIOPin* pin){ this->protocol_->set_discrete_open_pin(pin); }
-        void set_discrete_close_pin(InternalGPIOPin* pin){ this->protocol_->set_discrete_close_pin(pin); }
+        void set_dry_contact_open_sensor(esphome::binary_sensor::BinarySensor* dry_contact_open_sensor_);
+        void set_dry_contact_close_sensor(esphome::binary_sensor::BinarySensor* dry_contact_close_sensor_);
+        void set_discrete_open_pin(InternalGPIOPin* pin) { this->protocol_->set_discrete_open_pin(pin); }
+        void set_discrete_close_pin(InternalGPIOPin* pin) { this->protocol_->set_discrete_close_pin(pin); }
+#endif
 
         Result call_protocol(Args args);
 
@@ -176,13 +181,15 @@ namespace ratgdo {
     protected:
         RATGDOStore isr_store_ {};
         protocol::Protocol* protocol_;
-        bool obstruction_from_status_ { false };
+        bool obstruction_sensor_detected_ { false };
 
         InternalGPIOPin* output_gdo_pin_;
         InternalGPIOPin* input_gdo_pin_;
         InternalGPIOPin* input_obst_pin_;
-        esphome::gpio::GPIOBinarySensor* dry_contact_open_sensor_;
-        esphome::gpio::GPIOBinarySensor* dry_contact_close_sensor_;
+#ifdef PROTOCOL_DRYCONTACT
+        esphome::binary_sensor::BinarySensor* dry_contact_open_sensor_;
+        esphome::binary_sensor::BinarySensor* dry_contact_close_sensor_;
+#endif
     }; // RATGDOComponent
 
 } // namespace ratgdo

components/ratgdo/secplus1.h

@@ -97,11 +97,10 @@ namespace ratgdo {
             const Traits& traits() const { return this->traits_; }
 
             // methods not used by secplus1
-            void set_open_limit(bool state){}
-            void set_close_limit(bool state){}
-            void set_discrete_open_pin(InternalGPIOPin* pin){}
-            void set_discrete_close_pin(InternalGPIOPin* pin){}
-
+            void set_open_limit(bool state) { }
+            void set_close_limit(bool state) { }
+            void set_discrete_open_pin(InternalGPIOPin* pin) { }
+            void set_discrete_close_pin(InternalGPIOPin* pin) { }
 
         protected:
             void wall_panel_emulation(size_t index = 0);

components/ratgdo/secplus2.h

@@ -102,10 +102,10 @@ namespace ratgdo {
             const Traits& traits() const { return this->traits_; }
 
             // methods not used by secplus2
-            void set_open_limit(bool state){}
-            void set_close_limit(bool state){}
-            void set_discrete_open_pin(InternalGPIOPin* pin){}
-            void set_discrete_close_pin(InternalGPIOPin* pin){}
+            void set_open_limit(bool state) { }
+            void set_close_limit(bool state) { }
+            void set_discrete_open_pin(InternalGPIOPin* pin) { }
+            void set_discrete_close_pin(InternalGPIOPin* pin) { }
 
         protected:
             void increment_rolling_code_counter(int delta = 1);