kenjreno
/
esphome-ratgdo
mirror of https://github.com/ratgdo/esphome-ratgdo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: Security Plus v1 support (#171) 

Co-authored-by: Marius Muja <mariusmuja@gmail.com>
This commit is contained in:
J. Nick Koston 2024-01-19 13:24:16 -10:00 committed by GitHub
parent 4c2ed4e7c0
commit f3f8f966dc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 2290 additions and 682 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
.github/workflows/build.yml vendored
View File

@ -17,26 +17,29 @@ jobs:
matrix:
firmware:
- file: v2board_esp8266_d1_mini_lite.yaml
name: V2.0 Board ESP8266 D1 Mini Lite
name: V2.0 Board ESP8266 D1 Mini Lite Security+ 2.0
manifest_filename: v2board_esp8266_d1_mini_lite-manifest.json
- file: v2board_esp8266_d1_mini.yaml
name: V2.0 Board ESP8266 D1 Mini
name: V2.0 Board ESP8266 D1 Mini Security+ 2.0
manifest_filename: v2board_esp8266_d1_mini-manifest.json
- file: v2board_esp32_d1_mini.yaml
name: V2.0 Board ESP32 D1 Mini
name: V2.0 Board ESP32 D1 Mini Security+ 2.0
manifest_filename: v2board_esp32_d1_mini-manifest.json
- file: v2board_esp32_lolin_s2_mini.yaml
name: V2.0 Board ESP32 lolin S2 mini
name: V2.0 Board ESP32 lolin S2 mini Security+ 2.0
manifest_filename: v2board_esp32_lolin_s2_mini-manifest.json
- file: v25board_esp8266_d1_mini_lite.yaml
name: V2.5 Board ESP8266 D1 Mini Lite
name: V2.5 Board ESP8266 D1 Mini Lite Security+ 2.0
manifest_filename: v25board_esp8266_d1_mini_lite-manifest.json
- file: v25board_esp32_d1_mini.yaml
name: V2.5 Board ESP32 D1 Mini
name: V2.5 Board ESP32 D1 Mini Security+ 2.0
manifest_filename: v25board_esp32_d1_mini-manifest.json
- file: v25iboard.yaml
name: V2.5i Board
name: V2.5i Board Security+ 2.0
manifest_filename: v25iboard-manifest.json
- file: v25iboard_secplusv1.yaml
name: V2.5i Board Security+ 1.0
manifest_filename: v25iboard-manifest_secplusv1.json
fail-fast: false
steps:
- name: Checkout source code

15
README.md
View File

@ -19,13 +19,14 @@ The ESPHome firmware will allow you to open the door to any position after calib
## ESPHome config
- [ESPHome config for v2.0 board with ESP8266 D1 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp8266_d1_mini.yaml)
- [ESPHome config for v2.0 board with ESP8266 D1 Mini lite](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp8266_d1_mini_lite.yaml)
- [ESPHome config for v2.0 board with ESP32 D1 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp32_d1_mini.yaml)
- [ESPHome config for v2.0 board with ESP32 Lolin D2 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp32_lolin_s2_mini.yaml)
- [ESPHome config for v2.5 board with ESP8266 D1 Mini lite](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25board_esp8266_d1_mini_lite.yaml)
- [ESPHome config for v2.5 board with ESP32 D1 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25board_esp32_d1_mini.yaml)
- [ESPHome config for v2.5i board](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25iboard.yaml)
- [Security+ 2.0 ESPHome config for v2.0 board with ESP8266 D1 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp8266_d1_mini.yaml)
- [Security+ 2.0 ESPHome config for v2.0 board with ESP8266 D1 Mini lite](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp8266_d1_mini_lite.yaml)
- [Security+ 2.0 ESPHome config for v2.0 board with ESP32 D1 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp32_d1_mini.yaml)
- [Security+ 2.0 ESPHome config for v2.0 board with ESP32 Lolin D2 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v2board_esp32_lolin_s2_mini.yaml)
- [Security+ 2.0 ESPHome config for v2.5 board with ESP8266 D1 Mini lite](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25board_esp8266_d1_mini_lite.yaml)
- [Security+ 2.0 ESPHome config for v2.5 board with ESP32 D1 Mini](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25board_esp32_d1_mini.yaml)
- [Security+ 2.0 ESPHome config for v2.5i board](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25iboard.yaml)
- [Security+ 1.0 ESPHome config for v2.5i board](https://github.com/RATGDO/esphome-ratgdo/blob/main/static/v25iboard_secplusv1.yaml)
- [Web Installer](https://ratgdo.github.io/esphome-ratgdo/)

4
base.yaml
View File

@ -20,7 +20,7 @@ ratgdo:
service: persistent_notification.create
data:
title: "${friendly_name} sync failed"
message: "Failed to communicate with garage opener on startup; Check the ${friendly_name} Rolling code counter number entity history and set the entity to one number larger than the largest value in history. [ESPHome devices](/config/devices/dashboard?domain=esphome)"
message: "Failed to communicate with garage opener on startup."
notification_id: "esphome_ratgdo_${id_prefix}_sync_failed"
api:
services:
@ -263,4 +263,4 @@ button:
on_press:
then:
lambda: !lambda |-
id($id_prefix).toggle_door();
id($id_prefix).door_toggle();

209
base_secplusv1.yaml Normal file
View File

@ -0,0 +1,209 @@
---
external_components:
- source:
type: git
url: https://github.com/ratgdo/esphome-ratgdo
refresh: 1s
preferences:
flash_write_interval: 5s
ratgdo:
id: ${id_prefix}
input_gdo_pin: ${uart_rx_pin}
output_gdo_pin: ${uart_tx_pin}
input_obst_pin: ${input_obst_pin}
protocol: secplusv1
on_sync_failed:
then:
- homeassistant.service:
service: persistent_notification.create
data:
title: "${friendly_name} sync failed"
message: "Failed to communicate with garage opener on startup."
notification_id: "esphome_ratgdo_${id_prefix}_sync_failed"
lock:
- platform: ratgdo
id: ${id_prefix}_lock_remotes
ratgdo_id: ${id_prefix}
name: "Lock remotes"
switch:
- platform: gpio
id: "${id_prefix}_status_door"
internal: true
pin:
number: ${status_door_pin} # D0 output door status, HIGH for open, LOW for closed
mode:
output: true
name: "Status door"
entity_category: diagnostic
- platform: gpio
id: "${id_prefix}_status_obstruction"
internal: true
pin:
number: ${status_obstruction_pin} # D8 output for obstruction status, HIGH for obstructed, LOW for clear
mode:
output: true
name: "Status obstruction"
entity_category: diagnostic
binary_sensor:
- platform: ratgdo
type: motion
id: ${id_prefix}_motion
ratgdo_id: ${id_prefix}
name: "Motion"
device_class: motion
- platform: ratgdo
type: obstruction
id: ${id_prefix}_obstruction
ratgdo_id: ${id_prefix}
name: "Obstruction"
device_class: problem
on_press:
- switch.turn_on: ${id_prefix}_status_obstruction
on_release:
- switch.turn_off: ${id_prefix}_status_obstruction
- platform: ratgdo
type: button
id: ${id_prefix}_button
ratgdo_id: ${id_prefix}
name: "Button"
entity_category: diagnostic
- platform: gpio
id: "${id_prefix}_dry_contact_open"
pin:
number: ${dry_contact_open_pin} # D5 dry contact for opening door
inverted: true
mode:
input: true
pullup: true
name: "Dry contact open"
entity_category: diagnostic
filters:
- delayed_on_off: 500ms
on_press:
- if:
condition:
binary_sensor.is_off: ${id_prefix}_dry_contact_close
then:
- cover.open: ${id_prefix}_garage_door
- platform: gpio
id: "${id_prefix}_dry_contact_close"
pin:
number: ${dry_contact_close_pin} # D6 dry contact for closing door
inverted: true
mode:
input: true
pullup: true
name: "Dry contact close"
entity_category: diagnostic
filters:
- delayed_on_off: 500ms
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:
number: ${dry_contact_light_pin} # D3 dry contact for triggering light (no discrete light commands, so toggle only)
inverted: true
mode:
input: true
pullup: true
name: "Dry contact light"
entity_category: diagnostic
filters:
- delayed_on_off: 500ms
on_press:
- light.toggle: ${id_prefix}_light
number:
- platform: ratgdo
id: ${id_prefix}_rolling_code_counter
type: rolling_code_counter
entity_category: config
ratgdo_id: ${id_prefix}
name: "Rolling code counter"
mode: box
unit_of_measurement: "codes"
- platform: ratgdo
id: ${id_prefix}_opening_duration
type: opening_duration
entity_category: config
ratgdo_id: ${id_prefix}
name: "Opening duration"
unit_of_measurement: "s"
- platform: ratgdo
id: ${id_prefix}_closing_duration
type: closing_duration
entity_category: config
ratgdo_id: ${id_prefix}
name: "Closing duration"
unit_of_measurement: "s"
- platform: ratgdo
id: ${id_prefix}_client_id
type: client_id
entity_category: config
ratgdo_id: ${id_prefix}
name: "Client ID"
mode: box
cover:
- platform: ratgdo
id: ${id_prefix}_garage_door
device_class: garage
name: "Door"
ratgdo_id: ${id_prefix}
on_closed:
- switch.turn_off: ${id_prefix}_status_door
on_open:
- switch.turn_on: ${id_prefix}_status_door
light:
- platform: ratgdo
id: ${id_prefix}_light
name: "Light"
ratgdo_id: ${id_prefix}
button:
- platform: restart
name: "Restart"
- platform: safe_mode
name: "Safe mode boot"
entity_category: diagnostic
- platform: template
id: ${id_prefix}_query_status
entity_category: diagnostic
name: "Query status"
on_press:
then:
lambda: !lambda |-
id($id_prefix).query_status();
- platform: template
id: ${id_prefix}_sync
name: "Sync"
entity_category: diagnostic
on_press:
then:
lambda: !lambda |-
id($id_prefix).sync();
- platform: template
id: ${id_prefix}_toggle_door
name: "Toggle door"
on_press:
then:
lambda: !lambda |-
id($id_prefix).door_toggle();

25
components/ratgdo/__init__.py
View File

@ -1,5 +1,6 @@
import esphome.codegen as cg
import esphome.config_validation as cv
import voluptuous as vol
from esphome import automation, pins
from esphome.const import CONF_ID, CONF_TRIGGER_ID
@ -28,6 +29,12 @@ CONF_RATGDO_ID = "ratgdo_id"
CONF_ON_SYNC_FAILED = "on_sync_failed"
CONF_PROTOCOL = "protocol"
PROTOCOL_SECPLUSV1 = "secplusv1"
PROTOCOL_SECPLUSV2 = "secplusv2"
PROTOCOL_DRYCONTACT = "drycontact"
SUPPORTED_PROTOCOLS = [PROTOCOL_SECPLUSV1, PROTOCOL_SECPLUSV2, PROTOCOL_DRYCONTACT]
CONFIG_SCHEMA = cv.Schema(
{
@ -38,14 +45,17 @@ CONFIG_SCHEMA = cv.Schema(
cv.Optional(
CONF_INPUT_GDO, default=DEFAULT_INPUT_GDO
): pins.gpio_input_pin_schema,
cv.Optional(
CONF_INPUT_OBST, default=DEFAULT_INPUT_OBST
): pins.gpio_input_pin_schema,
cv.Optional(CONF_INPUT_OBST, default=DEFAULT_INPUT_OBST): cv.Any(
cv.none, pins.gpio_input_pin_schema
),
cv.Optional(CONF_ON_SYNC_FAILED): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SyncFailed),
}
),
cv.Optional(CONF_PROTOCOL, default=PROTOCOL_SECPLUSV2): vol.In(
SUPPORTED_PROTOCOLS
),
}
).extend(cv.COMPONENT_SCHEMA)
@ -68,6 +78,7 @@ async def to_code(config):
cg.add(var.set_output_gdo_pin(pin))
pin = await cg.gpio_pin_expression(config[CONF_INPUT_GDO])
cg.add(var.set_input_gdo_pin(pin))
if CONF_INPUT_OBST in config and config[CONF_INPUT_OBST]:
pin = await cg.gpio_pin_expression(config[CONF_INPUT_OBST])
cg.add(var.set_input_obst_pin(pin))
@ -85,3 +96,11 @@ async def to_code(config):
repository="https://github.com/ratgdo/espsoftwareserial#autobaud",
version=None,
)
if config[CONF_PROTOCOL] == PROTOCOL_SECPLUSV1:
cg.add_define("PROTOCOL_SECPLUSV1")
elif config[CONF_PROTOCOL] == PROTOCOL_SECPLUSV2:
cg.add_define("PROTOCOL_SECPLUSV2")
elif config[CONF_PROTOCOL] == PROTOCOL_DRYCONTACT:
cg.add_define("PROTOCOL_DRYCONTACT")
cg.add(var.init_protocol())

4
components/ratgdo/callbacks.h
View File

@ -13,9 +13,9 @@ namespace ratgdo {
class OnceCallbacks<void(Ts...)> {
public:
template <typename Callback>
void then(Callback&& callback) { this->callbacks_.push_back(std::forward<Callback>(callback)); }
void operator()(Callback&& callback) { this->callbacks_.push_back(std::forward<Callback>(callback)); }
void operator()(Ts... args)
void trigger(Ts... args)
{
for (auto& cb : this->callbacks_)
cb(args...);

4
components/ratgdo/common.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
#define ESP_LOG1 ESP_LOGV
#define ESP_LOG2 ESP_LOGV

13
components/ratgdo/cover/ratgdo_cover.cpp
View File

@ -27,6 +27,7 @@ namespace ratgdo {
void RATGDOCover::on_door_state(DoorState state, float position)
{
bool save_to_flash = true;
switch (state) {
case DoorState::OPEN:
this->position = COVER_OPEN;
@ -39,10 +40,12 @@ namespace ratgdo {
case DoorState::OPENING:
this->current_operation = COVER_OPERATION_OPENING;
this->position = position;
save_to_flash = false;
break;
case DoorState::CLOSING:
this->current_operation = COVER_OPERATION_CLOSING;
this->position = position;
save_to_flash = false;
break;
case DoorState::STOPPED:
this->current_operation = COVER_OPERATION_IDLE;
@ -55,7 +58,7 @@ namespace ratgdo {
break;
}
this->publish_state();
this->publish_state(save_to_flash);
}
CoverTraits RATGDOCover::get_traits()
@ -70,17 +73,17 @@ namespace ratgdo {
void RATGDOCover::control(const CoverCall& call)
{
if (call.get_stop()) {
this->parent_->stop_door();
this->parent_->door_stop();
}
if (call.get_toggle()) {
this->parent_->toggle_door();
this->parent_->door_toggle();
}
if (call.get_position().has_value()) {
auto pos = *call.get_position();
if (pos == COVER_OPEN) {
this->parent_->open_door();
this->parent_->door_open();
} else if (pos == COVER_CLOSED) {
this->parent_->close_door();
this->parent_->door_close();
} else {
this->parent_->door_move_to_position(pos);
}

69
components/ratgdo/dry_contact.cpp Normal file
View File

@ -0,0 +1,69 @@
#include "dry_contact.h"
#include "ratgdo.h"
#include "esphome/core/gpio.h"
#include "esphome/core/log.h"
#include "esphome/core/scheduler.h"
namespace esphome {
namespace ratgdo {
namespace dry_contact {
static const char* const TAG = "ratgdo_dry_contact";
void DryContact::setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin)
{
this->ratgdo_ = ratgdo;
this->scheduler_ = scheduler;
this->tx_pin_ = tx_pin;
this->rx_pin_ = rx_pin;
}
void DryContact::loop()
{
}
void DryContact::dump_config()
{
ESP_LOGCONFIG(TAG, " Protocol: dry contact");
}
void DryContact::sync()
{
}
void DryContact::light_action(LightAction action)
{
ESP_LOG1(TAG, "Ignoring light action: %s", LightAction_to_string(action));
return;
}
void DryContact::lock_action(LockAction action)
{
ESP_LOG1(TAG, "Ignoring lock action: %s", LockAction_to_string(action));
return;
}
void DryContact::door_action(DoorAction action)
{
if (action != DoorAction::TOGGLE) {
ESP_LOG1(TAG, "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_, "", 200, [=] {
this->tx_pin_->digital_write(0);
});
}
Result DryContact::call(Args args)
{
return {};
}
} // namespace DryContact
} // namespace ratgdo
} // namespace esphome

49
components/ratgdo/dry_contact.h Normal file
View File

@ -0,0 +1,49 @@
#pragma once
#include "SoftwareSerial.h" // Using espsoftwareserial https://github.com/plerup/espsoftwareserial
#include "esphome/core/optional.h"
#include "callbacks.h"
#include "observable.h"
#include "protocol.h"
#include "ratgdo_state.h"
namespace esphome {
class Scheduler;
class InternalGPIOPin;
namespace ratgdo {
namespace dry_contact {
using namespace esphome::ratgdo::protocol;
class DryContact : public Protocol {
public:
void setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin);
void loop();
void dump_config();
void sync();
void light_action(LightAction action);
void lock_action(LockAction action);
void door_action(DoorAction action);
Result call(Args args);
const Traits& traits() const { return this->traits_; }
protected:
Traits traits_;
InternalGPIOPin* tx_pin_;
InternalGPIOPin* rx_pin_;
RATGDOComponent* ratgdo_;
Scheduler* scheduler_;
};
} // namespace secplus1
} // namespace ratgdo
} // namespace esphome

1
components/ratgdo/light/ratgdo_light_output.cpp
View File

@ -31,7 +31,6 @@ namespace ratgdo {
void RATGDOLightOutput::set_state(esphome::ratgdo::LightState state)
{
bool is_on = state == LightState::ON;
this->light_state_->current_values.set_state(is_on);
this->light_state_->remote_values.set_state(is_on);

9
components/ratgdo/lock/__init__.py
View File

@ -9,15 +9,12 @@ DEPENDENCIES = ["ratgdo"]
RATGDOLock = ratgdo_ns.class_("RATGDOLock", lock.Lock, cg.Component)
CONFIG_SCHEMA = (
lock.LOCK_SCHEMA
.extend(
CONFIG_SCHEMA = lock.LOCK_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(RATGDOLock),
}
)
.extend(RATGDO_CLIENT_SCHMEA)
)
).extend(RATGDO_CLIENT_SCHMEA)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])

32
components/ratgdo/enum.h → components/ratgdo/macros.h
View File

@ -55,3 +55,35 @@
return _unknown; \
} \
}
#define SUM_TYPE_UNION_MEMBER0(type, var) type var;
#define SUM_TYPE_UNION_MEMBER(name, tuple) SUM_TYPE_UNION_MEMBER0 tuple
#define SUM_TYPE_ENUM_MEMBER0(type, var) var,
#define SUM_TYPE_ENUM_MEMBER(name, tuple) SUM_TYPE_ENUM_MEMBER0 tuple
#define SUM_TYPE_CONSTRUCTOR0(name, type, val) \
name(type&& arg) \
: tag(Tag::val) \
{ \
value.val = std::move(arg); \
}
#define SUM_TYPE_CONSTRUCTOR(name, tuple) SUM_TYPE_CONSTRUCTOR0 LPAREN name, TUPLE tuple)
#define SUM_TYPE(name, ...) \
class name { \
public: \
union { \
FOR_EACH(SUM_TYPE_UNION_MEMBER, name, __VA_ARGS__) \
} value; \
enum class Tag { \
void_, \
FOR_EACH(SUM_TYPE_ENUM_MEMBER, name, __VA_ARGS__) \
} tag; \
\
name() \
: tag(Tag::void_) \
{ \
} \
FOR_EACH(SUM_TYPE_CONSTRUCTOR, name, __VA_ARGS__) \
};

10
components/ratgdo/number/ratgdo_number.cpp
View File

@ -5,6 +5,9 @@
namespace esphome {
namespace ratgdo {
using protocol::SetClientID;
using protocol::SetRollingCodeCounter;
float normalize_client_id(float client_id)
{
uint32_t int_value = static_cast<uint32_t>(client_id);
@ -84,6 +87,9 @@ namespace ratgdo {
void RATGDONumber::update_state(float value)
{
if (value == this->state) {
return;
}
this->pref_.save(&value);
this->publish_state(value);
}
@ -91,14 +97,14 @@ namespace ratgdo {
void RATGDONumber::control(float value)
{
if (this->number_type_ == RATGDO_ROLLING_CODE_COUNTER) {
this->parent_->set_rolling_code_counter(value);
this->parent_->call_protocol(SetRollingCodeCounter { static_cast<uint32_t>(value) });
} else if (this->number_type_ == RATGDO_OPENING_DURATION) {
this->parent_->set_opening_duration(value);
} else if (this->number_type_ == RATGDO_CLOSING_DURATION) {
this->parent_->set_closing_duration(value);
} else if (this->number_type_ == RATGDO_CLIENT_ID) {
value = normalize_client_id(value);
this->parent_->set_client_id(value);
this->parent_->call_protocol(SetClientID { static_cast<uint32_t>(value) });
}
this->update_state(value);
}

117
components/ratgdo/protocol.h Normal file
View File

@ -0,0 +1,117 @@
#pragma once
#include "common.h"
#include "ratgdo_state.h"
namespace esphome {
class Scheduler;
class InternalGPIOPin;
namespace ratgdo {
class RATGDOComponent;
namespace protocol {
const uint32_t HAS_DOOR_OPEN = 1 << 0; // has idempotent open door command
const uint32_t HAS_DOOR_CLOSE = 1 << 1; // has idempotent close door command
const uint32_t HAS_DOOR_STOP = 1 << 2; // has idempotent stop door command
const uint32_t HAS_DOOR_STATUS = 1 << 3;
const uint32_t HAS_LIGHT_TOGGLE = 1 << 10; // some protocols might not support this
const uint32_t HAS_LOCK_TOGGLE = 1 << 20;
class Traits {
uint32_t value;
public:
Traits()
: value(0)
{
}
bool has_door_open() const { return this->value & HAS_DOOR_OPEN; }
bool has_door_close() const { return this->value & HAS_DOOR_CLOSE; }
bool has_door_stop() const { return this->value & HAS_DOOR_STOP; }
bool has_door_status() const { return this->value & HAS_DOOR_STATUS; }
bool has_light_toggle() const { return this->value & HAS_LIGHT_TOGGLE; }
bool has_lock_toggle() const { return this->value & HAS_LOCK_TOGGLE; }
void set_features(uint32_t feature) { this->value |= feature; }
void clear_features(uint32_t feature) { this->value &= ~feature; }
static uint32_t all()
{
return HAS_DOOR_CLOSE | HAS_DOOR_OPEN | HAS_DOOR_STOP | HAS_DOOR_STATUS | HAS_LIGHT_TOGGLE | HAS_LOCK_TOGGLE;
}
};
struct SetRollingCodeCounter {
uint32_t counter;
};
struct GetRollingCodeCounter {
};
struct SetClientID {
uint64_t client_id;
};
struct QueryStatus {
};
struct QueryOpenings {
};
struct ActivateLearn {
};
struct InactivateLearn {
};
struct QueryPairedDevices {
PairedDevice kind;
};
struct QueryPairedDevicesAll {
};
struct ClearPairedDevices {
PairedDevice kind;
};
// a poor man's sum-type, because C++
SUM_TYPE(Args,
(SetRollingCodeCounter, set_rolling_code_counter),
(GetRollingCodeCounter, get_rolling_code_counter),
(SetClientID, set_client_id),
(QueryStatus, query_status),
(QueryOpenings, query_openings),
(ActivateLearn, activate_learn),
(InactivateLearn, inactivate_learn),
(QueryPairedDevices, query_paired_devices),
(QueryPairedDevicesAll, query_paired_devices_all),
(ClearPairedDevices, clear_paired_devices), )
struct RollingCodeCounter {
observable<uint32_t>* value;
};
SUM_TYPE(Result,
(RollingCodeCounter, rolling_code_counter), )
class Protocol {
public:
virtual void setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin);
virtual void loop();
virtual void dump_config();
virtual void sync();
virtual const Traits& traits() const;
virtual void light_action(LightAction action);
virtual void lock_action(LockAction action);
virtual void door_action(DoorAction action);
virtual protocol::Result call(protocol::Args args);
};
}
} // namespace ratgdo
} // namespace esphome

691
components/ratgdo/ratgdo.cpp
View File

@ -12,29 +12,23 @@
************************************/
#include "ratgdo.h"
#include "common.h"
#include "dry_contact.h"
#include "ratgdo_state.h"
#include "secplus1.h"
#include "secplus2.h"
#include "esphome/core/application.h"
#include "esphome/core/gpio.h"
#include "esphome/core/log.h"
#define ESP_LOG1 ESP_LOGV
#define ESP_LOG2 ESP_LOGV
namespace esphome {
namespace ratgdo {
using namespace protocol;
static const char* const TAG = "ratgdo";
static const int SYNC_DELAY = 1000;
//
// MAX_CODES_WITHOUT_FLASH_WRITE is a bit of a guess
// since we write the flash at most every every 5s
//
// We want the rolling counter to be high enough that the
// GDO will accept the command after an unexpected reboot
// that did not save the counter to flash in time which
// results in the rolling counter being behind what the GDO
// expects.
//
static const uint8_t MAX_CODES_WITHOUT_FLASH_WRITE = 10;
void RATGDOComponent::setup()
{
@ -44,7 +38,7 @@ 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 || this->input_obst_pin_->get_pin() == 0) {
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;
@ -53,27 +47,34 @@ namespace ratgdo {
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->sw_serial_.begin(9600, SWSERIAL_8N1, this->input_gdo_pin_->get_pin(), this->output_gdo_pin_->get_pin(), true);
this->sw_serial_.enableIntTx(false);
this->sw_serial_.enableAutoBaud(true);
ESP_LOGV(TAG, "Syncing rolling code counter after reboot...");
this->protocol_->setup(this, &App.scheduler, this->input_gdo_pin_, this->output_gdo_pin_);
// many things happening at startup, use some delay for sync
set_timeout(SYNC_DELAY, [=] { this->sync(); });
}
// initializing protocol, this gets called before setup() because
// its children components might require that
void RATGDOComponent::init_protocol()
{
#ifdef PROTOCOL_SECPLUSV2
this->protocol_ = new secplus2::Secplus2();
#endif
#ifdef PROTOCOL_SECPLUSV1
this->protocol_ = new secplus1::Secplus1();
#endif
#ifdef PROTOCOL_DRYCONTACT
this->protocol_ = new dry_contact::DryContact();
#endif
}
void RATGDOComponent::loop()
{
if (this->transmit_pending_) {
if (!this->transmit_packet()) {
return;
}
}
if (!this->obstruction_from_status_) {
this->obstruction_loop();
}
this->gdo_state_loop();
this->protocol_->loop();
}
void RATGDOComponent::dump_config()
@ -86,40 +87,19 @@ namespace ratgdo {
} else {
LOG_PIN(" Input Obstruction Pin: ", this->input_obst_pin_);
}
ESP_LOGCONFIG(TAG, " Rolling Code Counter: %d", *this->rolling_code_counter);
ESP_LOGCONFIG(TAG, " Client ID: %d", this->client_id_);
this->protocol_->dump_config();
}
uint16_t RATGDOComponent::decode_packet(const WirePacket& packet)
void RATGDOComponent::received(const DoorState door_state)
{
uint32_t rolling = 0;
uint64_t fixed = 0;
uint32_t data = 0;
ESP_LOGD(TAG, "Door state=%s", DoorState_to_string(door_state));
decode_wireline(packet, &rolling, &fixed, &data);
uint16_t cmd = ((fixed >> 24) & 0xf00) | (data & 0xff);
data &= ~0xf000; // clear parity nibble
if ((fixed & 0xFFFFFFFF) == this->client_id_) { // my commands
ESP_LOG1(TAG, "[%ld] received mine: rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), rolling, fixed, data);
return static_cast<uint16_t>(Command::UNKNOWN);
} else {
ESP_LOG1(TAG, "[%ld] received rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), rolling, fixed, data);
}
Command cmd_enum = to_Command(cmd, Command::UNKNOWN);
uint8_t nibble = (data >> 8) & 0xff;
uint8_t byte1 = (data >> 16) & 0xff;
uint8_t byte2 = (data >> 24) & 0xff;
ESP_LOG1(TAG, "cmd=%03x (%s) byte2=%02x byte1=%02x nibble=%01x", cmd, Command_to_string(cmd_enum), byte2, byte1, nibble);
if (cmd == Command::STATUS) {
auto door_state = to_DoorState(nibble, DoorState::UNKNOWN);
auto prev_door_state = *this->door_state;
if (prev_door_state == door_state) {
return;
}
// opening duration calibration
if (*this->opening_duration == 0) {
if (door_state == DoorState::OPENING && prev_door_state == DoorState::CLOSED) {
@ -159,7 +139,9 @@ namespace ratgdo {
if (this->door_move_delta == DOOR_DELTA_UNKNOWN) {
this->door_move_delta = 1.0 - this->door_start_position;
}
if (*this->opening_duration != 0) {
this->schedule_door_position_sync();
}
} else if (door_state == DoorState::CLOSING) {
// door started closing
if (prev_door_state == DoorState::OPENING) {
@ -172,13 +154,16 @@ namespace ratgdo {
if (this->door_move_delta == DOOR_DELTA_UNKNOWN) {
this->door_move_delta = 0.0 - this->door_start_position;
}
if (*this->closing_duration != 0) {
this->schedule_door_position_sync();
}
} else if (door_state == DoorState::STOPPED) {
this->door_position_update();
if (*this->door_position == DOOR_POSITION_UNKNOWN) {
this->door_position = 0.5; // best guess
}
this->cancel_position_sync_callbacks();
cancel_timeout("door_query_state");
} else if (door_state == DoorState::OPEN) {
this->door_position = 1.0;
this->cancel_position_sync_callbacks();
@ -187,94 +172,132 @@ namespace ratgdo {
this->cancel_position_sync_callbacks();
}
this->door_state = door_state;
this->door_state_received(door_state);
this->light_state = static_cast<LightState>((byte2 >> 1) & 1); // safe because it can only be 0 or 1
this->lock_state = static_cast<LockState>(byte2 & 1); // safe because it can only be 0 or 1
this->motion_state = MotionState::CLEAR; // when the status message is read, reset motion state to 0|clear
this->motor_state = MotorState::OFF; // when the status message is read, reset motor state to 0|off
auto learn_state = static_cast<LearnState>((byte2 >> 5) & 1);
if (*this->learn_state != learn_state) {
if (learn_state == LearnState::INACTIVE) {
this->query_paired_devices();
}
this->learn_state = learn_state;
}
if (this->obstruction_from_status_) {
// ESP_LOGD(TAG, "Obstruction: reading from byte2, bit2, status=%d", ((byte2 >> 2) & 1) == 1);
this->obstruction_state = static_cast<ObstructionState>((byte1 >> 6) & 1);
// This isn't very fast to update, but its still better
// than nothing in the case the obstruction sensor is not
// wired up.
ESP_LOGD(TAG, "Obstruction: reading from GDO status byte1, bit6=%s", ObstructionState_to_string(*this->obstruction_state));
if (door_state == DoorState::OPEN || door_state == DoorState::CLOSED || door_state == DoorState::STOPPED) {
this->motor_state = MotorState::OFF;
}
if (door_state == DoorState::CLOSED && door_state != prev_door_state) {
this->send_command(Command::GET_OPENINGS);
this->query_openings();
}
ESP_LOGD(TAG, "Status: door=%s light=%s lock=%s learn=%s",
DoorState_to_string(*this->door_state),
LightState_to_string(*this->light_state),
LockState_to_string(*this->lock_state),
LearnState_to_string(*this->learn_state));
} else if (cmd == Command::LIGHT) {
if (nibble == 0) {
this->light_state = LightState::OFF;
} else if (nibble == 1) {
this->light_state = LightState::ON;
} else if (nibble == 2) { // toggle
this->light_state = light_state_toggle(*this->light_state);
this->door_state = door_state;
this->on_door_state_.trigger(door_state);
}
ESP_LOGD(TAG, "Light: action=%s state=%s",
nibble == 0 ? "OFF" : nibble == 1 ? "ON"
: "TOGGLE",
LightState_to_string(*this->light_state));
} else if (cmd == Command::MOTOR_ON) {
this->motor_state = MotorState::ON;
void RATGDOComponent::received(const LearnState learn_state)
{
ESP_LOGD(TAG, "Learn state=%s", LearnState_to_string(learn_state));
if (*this->learn_state == learn_state) {
return;
}
if (learn_state == LearnState::INACTIVE) {
this->query_paired_devices();
}
this->learn_state = learn_state;
}
void RATGDOComponent::received(const LightState light_state)
{
ESP_LOGD(TAG, "Light state=%s", LightState_to_string(light_state));
this->light_state = light_state;
}
void RATGDOComponent::received(const LockState lock_state)
{
ESP_LOGD(TAG, "Lock state=%s", LockState_to_string(lock_state));
this->lock_state = lock_state;
}
void RATGDOComponent::received(const ObstructionState obstruction_state)
{
if (this->obstruction_from_status_) {
ESP_LOGD(TAG, "Obstruction: state=%s", ObstructionState_to_string(*this->obstruction_state));
this->obstruction_state = obstruction_state;
// This isn't very fast to update, but its still better
// than nothing in the case the obstruction sensor is not
// wired up.
}
}
void RATGDOComponent::received(const MotorState motor_state)
{
ESP_LOGD(TAG, "Motor: state=%s", MotorState_to_string(*this->motor_state));
} else if (cmd == Command::DOOR_ACTION) {
this->button_state = (byte1 & 1) == 1 ? ButtonState::PRESSED : ButtonState::RELEASED;
ESP_LOGD(TAG, "Open: button=%s", ButtonState_to_string(*this->button_state));
} else if (cmd == Command::OPENINGS) {
// nibble==0 if it's our request
// update openings only from our request or if it's not unknown state
if (nibble == 0 || *this->openings != 0) {
this->openings = (byte1 << 8) | byte2;
ESP_LOGD(TAG, "Openings: %d", *this->openings);
} else {
ESP_LOGD(TAG, "Ignoring openings, not from our request");
this->motor_state = motor_state;
}
} else if (cmd == Command::MOTION) {
this->motion_state = MotionState::DETECTED;
void RATGDOComponent::received(const ButtonState button_state)
{
ESP_LOGD(TAG, "Button state=%s", ButtonState_to_string(*this->button_state));
this->button_state = button_state;
}
void RATGDOComponent::received(const MotionState motion_state)
{
ESP_LOGD(TAG, "Motion: %s", MotionState_to_string(*this->motion_state));
this->motion_state = motion_state;
if (motion_state == MotionState::DETECTED) {
this->set_timeout("clear_motion", 3000, [=] {
this->motion_state = MotionState::CLEAR;
});
if (*this->light_state == LightState::OFF) {
this->send_command(Command::GET_STATUS);
this->query_status();
}
ESP_LOGD(TAG, "Motion: %s", MotionState_to_string(*this->motion_state));
} else if (cmd == Command::SET_TTC) {
auto seconds = (byte1 << 8) | byte2;
ESP_LOGD(TAG, "Time to close (TTC): %ds", seconds);
} else if (cmd == Command::PAIRED_DEVICES) {
if (nibble == static_cast<uint8_t>(PairedDevice::ALL)) {
this->paired_total = byte2;
} else if (nibble == static_cast<uint8_t>(PairedDevice::REMOTE)) {
this->paired_remotes = byte2;
} else if (nibble == static_cast<uint8_t>(PairedDevice::KEYPAD)) {
this->paired_keypads = byte2;
} else if (nibble == static_cast<uint8_t>(PairedDevice::WALL_CONTROL)) {
this->paired_wall_controls = byte2;
} else if (nibble == static_cast<uint8_t>(PairedDevice::ACCESSORY)) {
this->paired_accessories = byte2;
}
}
return cmd;
void RATGDOComponent::received(const LightAction light_action)
{
ESP_LOGD(TAG, "Light cmd=%s state=%s",
LightAction_to_string(light_action),
LightState_to_string(*this->light_state));
if (light_action == LightAction::OFF) {
this->light_state = LightState::OFF;
} else if (light_action == LightAction::ON) {
this->light_state = LightState::ON;
} else if (light_action == LightAction::TOGGLE) {
this->light_state = light_state_toggle(*this->light_state);
}
}
void RATGDOComponent::received(const Openings openings)
{
if (openings.flag == 0 || *this->openings != 0) {
this->openings = openings.count;
ESP_LOGD(TAG, "Openings: %d", *this->openings);
} else {
ESP_LOGD(TAG, "Ignoring openings, not from our request");
}
}
void RATGDOComponent::received(const PairedDeviceCount pdc)
{
ESP_LOGD(TAG, "Paired device count, kind=%s count=%d", PairedDevice_to_string(pdc.kind), pdc.count);
if (pdc.kind == PairedDevice::ALL) {
this->paired_total = pdc.count;
} else if (pdc.kind == PairedDevice::REMOTE) {
this->paired_remotes = pdc.count;
} else if (pdc.kind == PairedDevice::KEYPAD) {
this->paired_keypads = pdc.count;
} else if (pdc.kind == PairedDevice::WALL_CONTROL) {
this->paired_wall_controls = pdc.count;
} else if (pdc.kind == PairedDevice::ACCESSORY) {
this->paired_accessories = pdc.count;
}
}
void RATGDOComponent::received(const TimeToClose ttc)
{
ESP_LOGD(TAG, "Time to close (TTC): %ds", ttc.seconds);
}
void RATGDOComponent::received(const BatteryState battery_state)
{
ESP_LOGD(TAG, "Battery state=%s", BatteryState_to_string(battery_state));
}
void RATGDOComponent::schedule_door_position_sync(float update_period)
@ -282,6 +305,9 @@ namespace ratgdo {
ESP_LOG1(TAG, "Schedule position sync: delta %f, start position: %f, start moving: %d",
this->door_move_delta, this->door_start_position, this->door_start_moving);
auto duration = this->door_move_delta > 0 ? *this->opening_duration : *this->closing_duration;
if (duration == 0) {
return;
}
auto count = int(1000 * duration / update_period);
set_retry("position_sync_while_moving", update_period, count, [=](uint8_t r) {
this->door_position_update();
@ -296,25 +322,14 @@ namespace ratgdo {
}
auto now = millis();
auto duration = this->door_move_delta > 0 ? *this->opening_duration : -*this->closing_duration;
if (duration == 0) {
return;
}
auto position = this->door_start_position + (now - this->door_start_moving) / (1000 * duration);
ESP_LOG2(TAG, "[%d] Position update: %f", now, position);
this->door_position = clamp(position, 0.0f, 1.0f);
}
void RATGDOComponent::encode_packet(Command command, uint32_t data, bool increment, WirePacket& packet)
{
auto cmd = static_cast<uint64_t>(command);
uint64_t fixed = ((cmd & ~0xff) << 24) | this->client_id_;
uint32_t send_data = (data << 8) | (cmd & 0xff);
ESP_LOG2(TAG, "[%ld] Encode for transmit rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), *this->rolling_code_counter, fixed, send_data);
encode_wireline(*this->rolling_code_counter, fixed, send_data, packet);
if (increment) {
this->increment_rolling_code_counter();
}
}
void RATGDOComponent::set_opening_duration(float duration)
{
ESP_LOGD(TAG, "Set opening duration: %.1fs", duration);
@ -327,39 +342,9 @@ namespace ratgdo {
this->closing_duration = duration;
}
void RATGDOComponent::set_rolling_code_counter(uint32_t counter)
Result RATGDOComponent::call_protocol(Args args)
{
ESP_LOGV(TAG, "Set rolling code counter to %d", counter);
this->rolling_code_counter = counter;
}
void RATGDOComponent::increment_rolling_code_counter(int delta)
{
this->rolling_code_counter = (*this->rolling_code_counter + delta) & 0xfffffff;
}
void RATGDOComponent::print_packet(const WirePacket& packet) const
{
ESP_LOG2(TAG, "Packet: [%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X]",
packet[0],
packet[1],
packet[2],
packet[3],
packet[4],
packet[5],
packet[6],
packet[7],
packet[8],
packet[9],
packet[10],
packet[11],
packet[12],
packet[13],
packet[14],
packet[15],
packet[16],
packet[17],
packet[18]);
return this->protocol_->call(args);
}
/*************************** OBSTRUCTION DETECTION ***************************/
@ -405,247 +390,54 @@ namespace ratgdo {
}
}
void RATGDOComponent::gdo_state_loop()
{
static bool reading_msg = false;
static uint32_t msg_start = 0;
static uint16_t byte_count = 0;
static WirePacket rx_packet;
static uint32_t last_read = 0;
if (!reading_msg) {
while (this->sw_serial_.available()) {
uint8_t ser_byte = this->sw_serial_.read();
last_read = millis();
if (ser_byte != 0x55 && ser_byte != 0x01 && ser_byte != 0x00) {
ESP_LOG2(TAG, "Ignoring byte (%d): %02X, baud: %d", byte_count, ser_byte, this->sw_serial_.baudRate());
byte_count = 0;
continue;
}
msg_start = ((msg_start << 8) | ser_byte) & 0xffffff;
byte_count++;
// if we are at the start of a message, capture the next 16 bytes
if (msg_start == 0x550100) {
ESP_LOG1(TAG, "Baud: %d", this->sw_serial_.baudRate());
rx_packet[0] = 0x55;
rx_packet[1] = 0x01;
rx_packet[2] = 0x00;
reading_msg = true;
break;
}
}
}
if (reading_msg) {
while (this->sw_serial_.available()) {
uint8_t ser_byte = this->sw_serial_.read();
last_read = millis();
rx_packet[byte_count] = ser_byte;
byte_count++;
// ESP_LOG2(TAG, "Received byte (%d): %02X, baud: %d", byte_count, ser_byte, this->sw_serial_.baudRate());
if (byte_count == PACKET_LENGTH) {
reading_msg = false;
byte_count = 0;
this->print_packet(rx_packet);
this->decode_packet(rx_packet);
return;
}
}
if (millis() - last_read > 100) {
// if we have a partial packet and it's been over 100ms since last byte was read,
// the rest is not coming (a full packet should be received in ~20ms),
// discard it so we can read the following packet correctly
ESP_LOGW(TAG, "Discard incomplete packet, length: %d", byte_count);
reading_msg = false;
byte_count = 0;
}
}
}
void RATGDOComponent::query_status()
{
send_command(Command::GET_STATUS);
this->protocol_->call(QueryStatus {});
}
void RATGDOComponent::query_openings()
{
send_command(Command::GET_OPENINGS);
this->protocol_->call(QueryOpenings {});
}
void RATGDOComponent::query_paired_devices()
{
const auto kinds = {
PairedDevice::ALL,
PairedDevice::REMOTE,
PairedDevice::KEYPAD,
PairedDevice::WALL_CONTROL,
PairedDevice::ACCESSORY
};
uint32_t timeout = 0;
for (auto kind : kinds) {
timeout += 200;
set_timeout(timeout, [=] { this->query_paired_devices(kind); });
}
this->protocol_->call(QueryPairedDevicesAll {});
}
void RATGDOComponent::query_paired_devices(PairedDevice kind)
{
ESP_LOGD(TAG, "Query paired devices of type: %s", PairedDevice_to_string(kind));
this->send_command(Command::GET_PAIRED_DEVICES, static_cast<uint8_t>(kind));
this->protocol_->call(QueryPairedDevices { kind });
}
// wipe devices from memory based on get paired devices nibble values
void RATGDOComponent::clear_paired_devices(PairedDevice kind)
{
if (kind == PairedDevice::UNKNOWN) {
return;
}
ESP_LOGW(TAG, "Clear paired devices of type: %s", PairedDevice_to_string(kind));
if (kind == PairedDevice::ALL) {
set_timeout(200, [=] { this->send_command(Command::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::REMOTE)-1); }); // wireless
set_timeout(400, [=] { this->send_command(Command::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::KEYPAD)-1); }); // keypads
set_timeout(600, [=] { this->send_command(Command::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::WALL_CONTROL)-1); }); // wall controls
set_timeout(800, [=] { this->send_command(Command::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::ACCESSORY)-1); }); // accessories
set_timeout(1000, [=] { this->query_status(); });
set_timeout(1200, [=] { this->query_paired_devices(); });
} else {
this->send_command(Command::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(kind) - 1); // just requested device
set_timeout(200, [=] { this->query_status(); });
set_timeout(400, [=] { this->query_paired_devices(kind); });
}
}
void RATGDOComponent::send_command(Command command, uint32_t data, bool increment)
{
ESP_LOG1(TAG, "Send command: %s, data: %08" PRIx32, Command_to_string(command), data);
if (!this->transmit_pending_) { // have an untransmitted packet
this->encode_packet(command, data, increment, this->tx_packet_);
} else {
// unlikely this would happed (unless not connected to GDO), we're ensuring any pending packet
// is transmitted each loop before doing anyting else
if (this->transmit_pending_start_ > 0) {
ESP_LOGW(TAG, "Have untransmitted packet, ignoring command: %s", Command_to_string(command));
} else {
ESP_LOGW(TAG, "Not connected to GDO, ignoring command: %s", Command_to_string(command));
}
}
this->transmit_packet();
}
void RATGDOComponent::send_command(Command command, uint32_t data, bool increment, std::function<void()>&& on_sent)
{
this->command_sent.then(on_sent);
this->send_command(command, data, increment);
}
bool RATGDOComponent::transmit_packet()
{
auto now = micros();
while (micros() - now < 1300) {
if (this->input_gdo_pin_->digital_read()) {
if (!this->transmit_pending_) {
this->transmit_pending_ = true;
this->transmit_pending_start_ = millis();
ESP_LOGD(TAG, "Collision detected, waiting to send packet");
} else {
if (millis() - this->transmit_pending_start_ < 5000) {
ESP_LOGD(TAG, "Collision detected, waiting to send packet");
} else {
this->transmit_pending_start_ = 0; // to indicate GDO not connected state
}
}
return false;
}
delayMicroseconds(100);
}
ESP_LOG2(TAG, "Sending packet");
this->print_packet(this->tx_packet_);
// indicate the start of a frame by pulling the 12V line low for at leat 1 byte followed by
// one STOP bit, which indicates to the receiving end that the start of the message follows
// The output pin is controlling a transistor, so the logic is inverted
this->output_gdo_pin_->digital_write(true); // pull the line low for at least 1 byte
delayMicroseconds(1300);
this->output_gdo_pin_->digital_write(false); // line high for at least 1 bit
delayMicroseconds(130);
this->sw_serial_.write(this->tx_packet_, PACKET_LENGTH);
this->transmit_pending_ = false;
this->transmit_pending_start_ = 0;
this->command_sent();
return true;
this->protocol_->call(ClearPairedDevices { kind });
}
void RATGDOComponent::sync()
{
auto sync_step = [=]() {
if (*this->door_state == DoorState::UNKNOWN) {
this->send_command(Command::GET_STATUS);
return RetryResult::RETRY;
}
if (*this->openings == 0) {
this->send_command(Command::GET_OPENINGS);
return RetryResult::RETRY;
}
if (*this->paired_total == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::ALL);
return RetryResult::RETRY;
}
if (*this->paired_remotes == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::REMOTE);
return RetryResult::RETRY;
}
if (*this->paired_keypads == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::KEYPAD);
return RetryResult::RETRY;
}
if (*this->paired_wall_controls == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::WALL_CONTROL);
return RetryResult::RETRY;
}
if (*this->paired_accessories == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::ACCESSORY);
return RetryResult::RETRY;
}
return RetryResult::DONE;
};
const uint8_t MAX_ATTEMPTS = 10;
set_retry(
500, MAX_ATTEMPTS, [=](uint8_t r) {
auto result = sync_step();
if (result == RetryResult::RETRY) {
if (r == MAX_ATTEMPTS - 2 && *this->door_state == DoorState::UNKNOWN) { // made a few attempts and no progress (door state is the first sync request)
// increment rolling code counter by some amount in case we crashed without writing to flash the latest value
this->increment_rolling_code_counter(MAX_CODES_WITHOUT_FLASH_WRITE);
}
if (r == 0) {
// this was last attempt, notify of sync failure
ESP_LOGD(TAG, "Triggering sync failed actions.");
this->sync_failed = true;
}
}
return result;
},
1.5f);
this->protocol_->sync();
}
void RATGDOComponent::open_door()
void RATGDOComponent::door_open()
{
if (*this->door_state == DoorState::OPENING) {
return; // gets ignored by opener
}
this->door_command(data::DOOR_OPEN);
this->door_action(DoorAction::OPEN);
// query state in case we don't get a status message
set_timeout("door_query_state", (*this->opening_duration + 1) * 1000, [=]() {
if (*this->door_state != DoorState::OPEN && *this->door_state != DoorState::STOPPED) {
this->door_state = DoorState::OPEN; // probably missed a status mesage, assume it's open
this->query_status(); // query in case we're wrong and it's stopped
}
});
}
void RATGDOComponent::close_door()
void RATGDOComponent::door_close()
{
if (*this->door_state == DoorState::CLOSING) {
return; // gets ignored by opener
@ -653,10 +445,10 @@ namespace ratgdo {
if (*this->door_state == DoorState::OPENING) {
// have to stop door first, otherwise close command is ignored
this->door_command(data::DOOR_STOP);
this->door_state_received.then([=](DoorState s) {
this->door_action(DoorAction::STOP);
this->on_door_state_([=](DoorState s) {
if (s == DoorState::STOPPED) {
this->door_command(data::DOOR_CLOSE);
this->door_action(DoorAction::CLOSE);
} else {
ESP_LOGW(TAG, "Door did not stop, ignoring close command");
}
@ -664,28 +456,41 @@ namespace ratgdo {
return;
}
this->door_command(data::DOOR_CLOSE);
this->door_action(DoorAction::CLOSE);
// query state in case we don't get a status message
set_timeout("door_query_state", (*this->closing_duration + 1) * 1000, [=]() {
if (*this->door_state != DoorState::CLOSED && *this->door_state != DoorState::STOPPED) {
this->door_state = DoorState::CLOSED; // probably missed a status mesage, assume it's closed
this->query_status(); // query in case we're wrong and it's stopped
}
});
}
void RATGDOComponent::stop_door()
void RATGDOComponent::door_stop()
{
if (*this->door_state != DoorState::OPENING && *this->door_state != DoorState::CLOSING) {
ESP_LOGW(TAG, "The door is not moving.");
return;
}
this->door_command(data::DOOR_STOP);
this->door_action(DoorAction::STOP);
}
void RATGDOComponent::toggle_door()
void RATGDOComponent::door_toggle()
{
this->door_command(data::DOOR_TOGGLE);
this->door_action(DoorAction::TOGGLE);
}
void RATGDOComponent::door_action(DoorAction action)
{
this->protocol_->door_action(action);
}
void RATGDOComponent::door_move_to_position(float position)
{
if (*this->door_state == DoorState::OPENING || *this->door_state == DoorState::CLOSING) {
this->door_command(data::DOOR_STOP);
this->door_state_received.then([=](DoorState s) {
this->door_action(DoorAction::STOP);
this->on_door_state_([=](DoorState s) {
if (s == DoorState::STOPPED) {
this->door_move_to_position(position);
}
@ -709,9 +514,9 @@ namespace ratgdo {
this->door_move_delta = delta;
ESP_LOGD(TAG, "Moving to position %.2f in %.1fs", position, operation_time / 1000.0);
this->door_command(delta > 0 ? data::DOOR_OPEN : data::DOOR_CLOSE);
this->door_action(delta > 0 ? DoorAction::OPEN : DoorAction::CLOSE);
set_timeout("move_to_position", operation_time, [=] {
this->ensure_door_command(data::DOOR_STOP);
this->door_action(DoorAction::STOP);
});
}
@ -728,80 +533,22 @@ namespace ratgdo {
}
}
void RATGDOComponent::door_command(uint32_t data)
{
data |= (1 << 16); // button 1 ?
data |= (1 << 8); // button press
this->send_command(Command::DOOR_ACTION, data, false, [=]() {
set_timeout(100, [=] {
auto data2 = data & ~(1 << 8); // button release
this->send_command(Command::DOOR_ACTION, data2);
});
});
}
void RATGDOComponent::ensure_door_command(uint32_t data, uint32_t delay)
{
if (data == data::DOOR_TOGGLE) {
ESP_LOGW(TAG, "It's not recommended to use ensure_door_command with non-idempotent commands such as DOOR_TOGGLE");
}
auto prev_door_state = *this->door_state;
this->door_state_received.then([=](DoorState s) {
if ((data == data::DOOR_STOP) && (s != DoorState::STOPPED) && !(prev_door_state == DoorState::OPENING && s == DoorState::OPEN) && !(prev_door_state == DoorState::CLOSING && s == DoorState::CLOSED)) {
return;
}
if (data == data::DOOR_OPEN && !(s == DoorState::OPENING || s == DoorState::OPEN)) {
return;
}
if (data == data::DOOR_CLOSE && !(s == DoorState::CLOSED || s == DoorState::CLOSING)) {
return;
}
ESP_LOG1(TAG, "Received door status, cancel door command retry");
cancel_timeout("door_command_retry");
});
this->door_command(data);
ESP_LOG1(TAG, "Ensure door command, setup door command retry");
set_timeout("door_command_retry", delay, [=]() {
this->ensure_door_command(data);
});
}
void RATGDOComponent::light_on()
{
this->light_state = LightState::ON;
this->send_command(Command::LIGHT, data::LIGHT_ON);
this->protocol_->light_action(LightAction::ON);
}
void RATGDOComponent::light_off()
{
this->light_state = LightState::OFF;
this->send_command(Command::LIGHT, data::LIGHT_OFF);
this->protocol_->light_action(LightAction::OFF);
}
void RATGDOComponent::toggle_light()
void RATGDOComponent::light_toggle()
{
this->light_state = light_state_toggle(*this->light_state);
this->send_command(Command::LIGHT, data::LIGHT_TOGGLE);
}
// Lock functions
void RATGDOComponent::lock()
{
this->lock_state = LockState::LOCKED;
this->send_command(Command::LOCK, data::LOCK_ON);
}
void RATGDOComponent::unlock()
{
this->lock_state = LockState::UNLOCKED;
this->send_command(Command::LOCK, data::LOCK_OFF);
}
void RATGDOComponent::toggle_lock()
{
this->lock_state = lock_state_toggle(*this->lock_state);
this->send_command(Command::LOCK, data::LOCK_TOGGLE);
this->protocol_->light_action(LightAction::TOGGLE);
}
LightState RATGDOComponent::get_light_state() const
@ -809,28 +556,44 @@ namespace ratgdo {
return *this->light_state;
}
// Lock functions
void RATGDOComponent::lock()
{
this->lock_state = LockState::LOCKED;
this->protocol_->lock_action(LockAction::LOCK);
}
void RATGDOComponent::unlock()
{
this->lock_state = LockState::UNLOCKED;
this->protocol_->lock_action(LockAction::UNLOCK);
}
void RATGDOComponent::lock_toggle()
{
this->lock_state = lock_state_toggle(*this->lock_state);
this->protocol_->lock_action(LockAction::TOGGLE);
}
// Learn functions
void RATGDOComponent::activate_learn()
{
// Send LEARN with nibble = 0 then nibble = 1 to mimic wall control learn button
this->send_command(Command::LEARN, 0);
set_timeout(150, [=] { this->send_command(Command::LEARN, 1); });
set_timeout(500, [=] { this->send_command(Command::GET_STATUS); });
this->protocol_->call(ActivateLearn {});
}
void RATGDOComponent::inactivate_learn()
{
// Send LEARN twice with nibble = 0 to inactivate learn and get status to update switch state
this->send_command(Command::LEARN, 0);
set_timeout(150, [=] { this->send_command(Command::LEARN, 0); });
set_timeout(500, [=] { this->send_command(Command::GET_STATUS); });
this->protocol_->call(InactivateLearn {});
}
void RATGDOComponent::subscribe_rolling_code_counter(std::function<void(uint32_t)>&& f)
{
// change update to children is defered until after component loop
// if multiple changes occur during component loop, only the last one is notified
this->rolling_code_counter.subscribe([=](uint32_t state) { defer("rolling_code_counter", [=] { f(state); }); });
auto counter = this->protocol_->call(GetRollingCodeCounter {});
if (counter.tag == Result::Tag::rolling_code_counter) {
counter.value.rolling_code_counter.value->subscribe([=](uint32_t state) { defer("rolling_code_counter", [=] { f(state); }); });
}
}
void RATGDOComponent::subscribe_opening_duration(std::function<void(float)>&& f)
{

134
components/ratgdo/ratgdo.h
View File

@ -12,86 +12,28 @@
************************************/
#pragma once
#include "SoftwareSerial.h" // Using espsoftwareserial https://github.com/plerup/espsoftwareserial
#include "callbacks.h"
#include "enum.h"
#include "esphome/core/component.h"
#include "esphome/core/gpio.h"
#include "esphome/core/log.h"
#include "esphome/core/hal.h"
#include "esphome/core/preferences.h"
#include "callbacks.h"
#include "macros.h"
#include "observable.h"
extern "C" {
#include "secplus.h"
}
#include "protocol.h"
#include "ratgdo_state.h"
namespace esphome {
class InternalGPIOPin;
namespace ratgdo {
class RATGDOComponent;
typedef Parented<RATGDOComponent> RATGDOClient;
static const uint8_t PACKET_LENGTH = 19;
typedef uint8_t WirePacket[PACKET_LENGTH];
const float DOOR_POSITION_UNKNOWN = -1.0;
const float DOOR_DELTA_UNKNOWN = -2.0;
const uint16_t PAIRED_DEVICES_UNKNOWN = 0xFF;
namespace data {
const uint32_t LIGHT_OFF = 0;
const uint32_t LIGHT_ON = 1;
const uint32_t LIGHT_TOGGLE = 2;
const uint32_t LIGHT_TOGGLE2 = 3;
const uint32_t LOCK_OFF = 0;
const uint32_t LOCK_ON = 1;
const uint32_t LOCK_TOGGLE = 2;
const uint32_t DOOR_CLOSE = 0;
const uint32_t DOOR_OPEN = 1;
const uint32_t DOOR_TOGGLE = 2;
const uint32_t DOOR_STOP = 3;
}
ENUM(Command, uint16_t,
(UNKNOWN, 0x000),
(GET_STATUS, 0x080),
(STATUS, 0x081),
(OBST_1, 0x084), // sent when an obstruction happens?
(OBST_2, 0x085), // sent when an obstruction happens?
(PAIR_3, 0x0a0),
(PAIR_3_RESP, 0x0a1),
(LEARN, 0x181),
(LOCK, 0x18c),
(DOOR_ACTION, 0x280),
(LIGHT, 0x281),
(MOTOR_ON, 0x284),
(MOTION, 0x285),
(GET_PAIRED_DEVICES, 0x307), // nibble 0 for total, 1 wireless, 2 keypads, 3 wall, 4 accessories.
(PAIRED_DEVICES, 0x308), // byte2 holds number of paired devices
(CLEAR_PAIRED_DEVICES, 0x30D), // nibble 0 to clear remotes, 1 keypads, 2 wall, 3 accessories (offset from above)
(LEARN_1, 0x391),
(PING, 0x392),
(PING_RESP, 0x393),
(PAIR_2, 0x400),
(PAIR_2_RESP, 0x401),
(SET_TTC, 0x402), // ttc_in_seconds = (byte1<<8)+byte2
(CANCEL_TTC, 0x408), // ?
(TTC, 0x40a), // Time to close
(GET_OPENINGS, 0x48b),
(OPENINGS, 0x48c), // openings = (byte1<<8)+byte2
)
inline bool operator==(const uint16_t cmd_i, const Command& cmd_e) { return cmd_i == static_cast<uint16_t>(cmd_e); }
inline bool operator==(const Command& cmd_e, const uint16_t cmd_i) { return cmd_i == static_cast<uint16_t>(cmd_e); }
struct RATGDOStore {
int obstruction_low_count = 0; // count obstruction low pulses
@ -101,13 +43,18 @@ namespace ratgdo {
}
};
using protocol::Args;
using protocol::Result;
class RATGDOComponent : public Component {
public:
void setup() override;
void loop() override;
void dump_config() override;
observable<uint32_t> rolling_code_counter { 0 };
void init_protocol();
void obstruction_loop();
float start_opening { -1 };
observable<float> opening_duration { 0 };
@ -136,35 +83,38 @@ namespace ratgdo {
observable<MotionState> motion_state { MotionState::UNKNOWN };
observable<LearnState> learn_state { LearnState::UNKNOWN };
OnceCallbacks<void(DoorState)> door_state_received;
OnceCallbacks<void()> command_sent;
OnceCallbacks<void(DoorState)> on_door_state_;
observable<bool> sync_failed { false };
void set_output_gdo_pin(InternalGPIOPin* pin) { this->output_gdo_pin_ = pin; }
void set_input_gdo_pin(InternalGPIOPin* pin) { this->input_gdo_pin_ = pin; }
void set_input_obst_pin(InternalGPIOPin* pin) { this->input_obst_pin_ = pin; }
void set_client_id(uint64_t client_id) { this->client_id_ = client_id & 0xFFFFFFFF; }
void gdo_state_loop();
uint16_t decode_packet(const WirePacket& packet);
void obstruction_loop();
void send_command(Command command, uint32_t data = 0, bool increment = true);
void send_command(Command command, uint32_t data, bool increment, std::function<void()>&& on_sent);
bool transmit_packet();
void encode_packet(Command command, uint32_t data, bool increment, WirePacket& packet);
void print_packet(const WirePacket& packet) const;
Result call_protocol(Args args);
void increment_rolling_code_counter(int delta = 1);
void set_rolling_code_counter(uint32_t code);
void received(const DoorState door_state);
void received(const LightState light_state);
void received(const LockState lock_state);
void received(const ObstructionState obstruction_state);
void received(const LightAction light_action);
void received(const MotorState motor_state);
void received(const ButtonState button_state);
void received(const MotionState motion_state);
void received(const LearnState light_state);
void received(const Openings openings);
void received(const TimeToClose ttc);
void received(const PairedDeviceCount pdc);
void received(const BatteryState pdc);
// door
void door_command(uint32_t data);
void ensure_door_command(uint32_t data, uint32_t delay = 1500);
void toggle_door();
void open_door();
void close_door();
void stop_door();
void door_toggle();
void door_open();
void door_close();
void door_stop();
void door_action(DoorAction action);
void ensure_door_action(DoorAction action, uint32_t delay = 1500);
void door_move_to_position(float position);
void set_door_position(float door_position) { this->door_position = door_position; }
void set_opening_duration(float duration);
@ -174,13 +124,13 @@ namespace ratgdo {
void cancel_position_sync_callbacks();
// light
void toggle_light();
void light_toggle();
void light_on();
void light_off();
LightState get_light_state() const;
// lock
void toggle_lock();
void lock_toggle();
void lock();
void unlock();
@ -217,21 +167,13 @@ namespace ratgdo {
void subscribe_learn_state(std::function<void(LearnState)>&& f);
protected:
// tx data
bool transmit_pending_ { false };
uint32_t transmit_pending_start_ { 0 };
WirePacket tx_packet_;
RATGDOStore isr_store_ {};
SoftwareSerial sw_serial_;
protocol::Protocol* protocol_;
bool obstruction_from_status_ { false };
InternalGPIOPin* output_gdo_pin_;
InternalGPIOPin* input_gdo_pin_;
InternalGPIOPin* input_obst_pin_;
uint64_t client_id_ { 0x539 };
}; // RATGDOComponent
} // namespace ratgdo

41
components/ratgdo/ratgdo_state.h
View File

@ -12,7 +12,7 @@
************************************/
#pragma once
#include "enum.h"
#include "macros.h"
#include <cstdint>
namespace esphome {
@ -64,6 +64,11 @@ namespace ratgdo {
(RELEASED, 1),
(UNKNOWN, 2))
ENUM(BatteryState, uint8_t,
(UNKNOWN, 0),
(CHARGING, 0x6),
(FULL, 0x8))
/// Enum for learn states.
ENUM(LearnState, uint8_t,
(INACTIVE, 0),
@ -79,5 +84,39 @@ namespace ratgdo {
(ACCESSORY, 4),
(UNKNOWN, 0xff))
// actions
ENUM(LightAction, uint8_t,
(OFF, 0),
(ON, 1),
(TOGGLE, 2),
(UNKNOWN, 3))
ENUM(LockAction, uint8_t,
(UNLOCK, 0),
(LOCK, 1),
(TOGGLE, 2),
(UNKNOWN, 3))
ENUM(DoorAction, uint8_t,
(CLOSE, 0),
(OPEN, 1),
(TOGGLE, 2),
(STOP, 3),
(UNKNOWN, 4))
struct Openings {
uint16_t count;
uint8_t flag;
};
struct PairedDeviceCount {
PairedDevice kind;
uint16_t count;
};
struct TimeToClose {
uint16_t seconds;
};
} // namespace ratgdo
} // namespace esphome

452
components/ratgdo/secplus1.cpp Normal file
View File

@ -0,0 +1,452 @@
#include "secplus1.h"
#include "ratgdo.h"
#include "esphome/core/gpio.h"
#include "esphome/core/log.h"
#include "esphome/core/scheduler.h"
namespace esphome {
namespace ratgdo {
namespace secplus1 {
static const char* const TAG = "ratgdo_secplus1";
void Secplus1::setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin)
{
this->ratgdo_ = ratgdo;
this->scheduler_ = scheduler;
this->tx_pin_ = tx_pin;
this->rx_pin_ = rx_pin;
this->sw_serial_.begin(1200, SWSERIAL_8E1, rx_pin->get_pin(), tx_pin->get_pin(), true);
this->traits_.set_features(HAS_DOOR_STATUS | HAS_LIGHT_TOGGLE | HAS_LOCK_TOGGLE);
}
void Secplus1::loop()
{
auto rx_cmd = this->read_command();
if (rx_cmd) {
this->handle_command(rx_cmd.value());
}
auto tx_cmd = this->pending_tx();
if (
(millis() - this->last_tx_) > 200 && // don't send twice in a period
(millis() - this->last_rx_) > 50 && // time to send it
tx_cmd && // have pending command
!(this->is_0x37_panel_ && tx_cmd.value() == CommandType::TOGGLE_LOCK_PRESS) && this->wall_panel_emulation_state_ != WallPanelEmulationState::RUNNING) {
this->do_transmit_if_pending();
}
}
void Secplus1::dump_config()
{
ESP_LOGCONFIG(TAG, " Protocol: SEC+ v1");
}
void Secplus1::sync()
{
this->wall_panel_emulation_state_ = WallPanelEmulationState::WAITING;
this->wall_panel_emulation_start_ = millis();
this->door_state = DoorState::UNKNOWN;
this->light_state = LightState::UNKNOWN;
this->scheduler_->cancel_timeout(this->ratgdo_, "wall_panel_emulation");
this->wall_panel_emulation();
this->scheduler_->set_timeout(this->ratgdo_, "", 45000, [=] {
if (this->door_state == DoorState::UNKNOWN) {
ESP_LOGW(TAG, "Triggering sync failed actions.");
this->ratgdo_->sync_failed = true;
}
});
}
void Secplus1::wall_panel_emulation(size_t index)
{
if (this->wall_panel_emulation_state_ == WallPanelEmulationState::WAITING) {
ESP_LOG1(TAG, "Looking for security+ 1.0 wall panel...");
if (this->door_state != DoorState::UNKNOWN || this->light_state != LightState::UNKNOWN) {
ESP_LOG1(TAG, "Wall panel detected");
return;
}
if (millis() - this->wall_panel_emulation_start_ > 35000 && !this->wall_panel_starting_) {
ESP_LOG1(TAG, "No wall panel detected. Switching to emulation mode.");
this->wall_panel_emulation_state_ = WallPanelEmulationState::RUNNING;
}
this->scheduler_->set_timeout(this->ratgdo_, "wall_panel_emulation", 2000, [=] {
this->wall_panel_emulation();
});
return;
} else if (this->wall_panel_emulation_state_ == WallPanelEmulationState::RUNNING) {
// ESP_LOG2(TAG, "[Wall panel emulation] Sending byte: [%02X]", secplus1_states[index]);
if (index < 15 || !this->do_transmit_if_pending()) {
this->transmit_byte(secplus1_states[index]);
// gdo response simulation for testing
// auto resp = secplus1_states[index] == 0x39 ? 0x00 :
// secplus1_states[index] == 0x3A ? 0x5C :
// secplus1_states[index] == 0x38 ? 0x52 : 0xFF;
// if (resp != 0xFF) {
// this->transmit_byte(resp, true);
// }
index += 1;
if (index == 18) {
index = 15;
}
}
this->scheduler_->set_timeout(this->ratgdo_, "wall_panel_emulation", 250, [=] {
this->wall_panel_emulation(index);
});
}
}
void Secplus1::light_action(LightAction action)
{
ESP_LOG1(TAG, "Light action: %s", LightAction_to_string(action));
if (action == LightAction::UNKNOWN) {
return;
}
if (
action == LightAction::TOGGLE || (action == LightAction::ON && this->light_state == LightState::OFF) || (action == LightAction::OFF && this->light_state == LightState::ON)) {
this->toggle_light();
}
}
void Secplus1::lock_action(LockAction action)
{
ESP_LOG1(TAG, "Lock action: %s", LockAction_to_string(action));
if (action == LockAction::UNKNOWN) {
return;
}
if (
action == LockAction::TOGGLE || (action == LockAction::LOCK && this->lock_state == LockState::UNLOCKED) || (action == LockAction::UNLOCK && this->lock_state == LockState::LOCKED)) {
this->toggle_lock();
}
}
void Secplus1::door_action(DoorAction action)
{
ESP_LOG1(TAG, "Door action: %s, door state: %s", DoorAction_to_string(action), DoorState_to_string(this->door_state));
if (action == DoorAction::UNKNOWN) {
return;
}
const uint32_t double_toggle_delay = 1000;
if (action == DoorAction::TOGGLE) {
this->toggle_door();
} else if (action == DoorAction::OPEN) {
if (this->door_state == DoorState::CLOSED || this->door_state == DoorState::CLOSING) {
this->toggle_door();
} else if (this->door_state == DoorState::STOPPED) {
this->toggle_door(); // this starts closing door
this->on_door_state_([=](DoorState s) {
if (s == DoorState::CLOSING) {
// this changes direction of the door on some openers, on others it stops it
this->toggle_door();
this->on_door_state_([=](DoorState s) {
if (s == DoorState::STOPPED) {
this->toggle_door();
}
});
}
});
}
} else if (action == DoorAction::CLOSE) {
if (this->door_state == DoorState::OPEN) {
this->toggle_door();
} else if (this->door_state == DoorState::OPENING) {
this->toggle_door(); // this switches to stopped
// another toggle needed to close
this->on_door_state_([=](DoorState s) {
if (s == DoorState::STOPPED) {
this->toggle_door();
}
});
} else if (this->door_state == DoorState::STOPPED) {
this->toggle_door();
}
} else if (action == DoorAction::STOP) {
if (this->door_state == DoorState::OPENING) {
this->toggle_door();
} else if (this->door_state == DoorState::CLOSING) {
this->toggle_door(); // this switches to opening
// another toggle needed to stop
this->on_door_state_([=](DoorState s) {
if (s == DoorState::OPENING) {
this->toggle_door();
}
});
}
}
}
void Secplus1::toggle_light()
{
this->enqueue_transmit(CommandType::TOGGLE_LIGHT_PRESS);
}
void Secplus1::toggle_lock()
{
this->enqueue_transmit(CommandType::TOGGLE_LOCK_PRESS);
}
void Secplus1::toggle_door()
{
this->enqueue_transmit(CommandType::TOGGLE_DOOR_PRESS);
this->enqueue_transmit(CommandType::QUERY_DOOR_STATUS);
if (this->door_state == DoorState::STOPPED || this->door_state == DoorState::OPEN || this->door_state == DoorState::CLOSED) {
this->door_moving_ = true;
}
}
Result Secplus1::call(Args args)
{
return {};
}
optional<RxCommand> Secplus1::read_command()
{
static bool reading_msg = false;
static uint32_t msg_start = 0;
static uint16_t byte_count = 0;
static RxPacket rx_packet;
if (!reading_msg) {
while (this->sw_serial_.available()) {
uint8_t ser_byte = this->sw_serial_.read();
this->last_rx_ = millis();
if (ser_byte < 0x30 || ser_byte > 0x3A) {
ESP_LOG2(TAG, "[%d] Ignoring byte [%02X], baud: %d", millis(), ser_byte, this->sw_serial_.baudRate());
byte_count = 0;
continue;
}
rx_packet[byte_count++] = ser_byte;
ESP_LOG2(TAG, "[%d] Received byte: [%02X]", millis(), ser_byte);
reading_msg = true;
if (ser_byte == 0x37 || (ser_byte >= 0x30 && ser_byte <= 0x35)) {
rx_packet[byte_count++] = 0;
reading_msg = false;
byte_count = 0;
ESP_LOG2(TAG, "[%d] Received command: [%02X]", millis(), rx_packet[0]);
return this->decode_packet(rx_packet);
}
break;
}
}
if (reading_msg) {
while (this->sw_serial_.available()) {
uint8_t ser_byte = this->sw_serial_.read();
this->last_rx_ = millis();
rx_packet[byte_count++] = ser_byte;
ESP_LOG2(TAG, "[%d] Received byte: [%02X]", millis(), ser_byte);
if (byte_count == RX_LENGTH) {
reading_msg = false;
byte_count = 0;
this->print_rx_packet(rx_packet);
return this->decode_packet(rx_packet);
}
}
if (millis() - this->last_rx_ > 100) {
// if we have a partial packet and it's been over 100ms since last byte was read,
// the rest is not coming (a full packet should be received in ~20ms),
// discard it so we can read the following packet correctly
ESP_LOGW(TAG, "[%d] Discard incomplete packet: [%02X ...]", millis(), rx_packet[0]);
reading_msg = false;
byte_count = 0;
}
}
return {};
}
void Secplus1::print_rx_packet(const RxPacket& packet) const
{
ESP_LOG2(TAG, "[%d] Received packet: [%02X %02X]", millis(), packet[0], packet[1]);
}
void Secplus1::print_tx_packet(const TxPacket& packet) const
{
ESP_LOG2(TAG, "[%d] Sending packet: [%02X %02X]", millis(), packet[0], packet[1]);
}
optional<RxCommand> Secplus1::decode_packet(const RxPacket& packet) const
{
CommandType cmd_type = to_CommandType(packet[0], CommandType::UNKNOWN);
return RxCommand { cmd_type, packet[1] };
}
// unknown meaning of observed command-responses:
// 40 00 and 40 80
// 53 01
// C0 3F
// F8 3F
// FE 3F
void Secplus1::handle_command(const RxCommand& cmd)
{
if (cmd.req == CommandType::QUERY_DOOR_STATUS) {
DoorState door_state;
auto val = cmd.resp & 0x7;
// 000 0x0 stopped
// 001 0x1 opening
// 010 0x2 open
// 100 0x4 closing
// 101 0x5 closed
// 110 0x6 stopped
if (val == 0x2) {
door_state = DoorState::OPEN;
} else if (val == 0x5) {
door_state = DoorState::CLOSED;
} else if (val == 0x0 || val == 0x6) {
door_state = DoorState::STOPPED;
} else if (val == 0x1) {
door_state = DoorState::OPENING;
} else if (val == 0x4) {
door_state = DoorState::CLOSING;
} else {
door_state = DoorState::UNKNOWN;
}
if (this->maybe_door_state != door_state) {
this->on_door_state_.trigger(door_state);
}
if (!this->is_0x37_panel_ && door_state != this->maybe_door_state) {
this->maybe_door_state = door_state;
ESP_LOG1(TAG, "Door maybe %s, waiting for 2nd status message to confirm", DoorState_to_string(door_state));
} else {
this->maybe_door_state = door_state;
this->door_state = door_state;
if (this->door_state == DoorState::STOPPED || this->door_state == DoorState::OPEN || this->door_state == DoorState::CLOSED) {
this->door_moving_ = false;
}
this->ratgdo_->received(door_state);
}
} else if (cmd.req == CommandType::QUERY_DOOR_STATUS_0x37) {
this->is_0x37_panel_ = true;
auto cmd = this->pending_tx();
if (cmd && cmd.value() == CommandType::TOGGLE_LOCK_PRESS) {
this->do_transmit_if_pending();
} else {
// inject door status request
if (door_moving_ || (millis() - this->last_status_query_ > 10000)) {
this->transmit_byte(static_cast<uint8_t>(CommandType::QUERY_DOOR_STATUS));
this->last_status_query_ = millis();
}
}
} else if (cmd.req == CommandType::QUERY_OTHER_STATUS) {
LightState light_state = to_LightState((cmd.resp >> 2) & 1, LightState::UNKNOWN);
if (!this->is_0x37_panel_ && light_state != this->maybe_light_state) {
this->maybe_light_state = light_state;
} else {
this->light_state = light_state;
this->ratgdo_->received(light_state);
}
LockState lock_state = to_LockState((~cmd.resp >> 3) & 1, LockState::UNKNOWN);
if (!this->is_0x37_panel_ && lock_state != this->maybe_lock_state) {
this->maybe_lock_state = lock_state;
} else {
this->lock_state = lock_state;
this->ratgdo_->received(lock_state);
}
} else if (cmd.req == CommandType::OBSTRUCTION) {
ObstructionState obstruction_state = cmd.resp == 0 ? ObstructionState::CLEAR : ObstructionState::OBSTRUCTED;
this->ratgdo_->received(obstruction_state);
} else if (cmd.req == CommandType::TOGGLE_DOOR_RELEASE) {
if (cmd.resp == 0x31) {
this->wall_panel_starting_ = true;
}
} else if (cmd.req == CommandType::TOGGLE_LIGHT_PRESS) {
// motion was detected, or the light toggle button was pressed
// either way it's ok to trigger motion detection
if (this->light_state == LightState::OFF) {
this->ratgdo_->received(MotionState::DETECTED);
}
} else if (cmd.req == CommandType::TOGGLE_DOOR_PRESS) {
this->ratgdo_->received(ButtonState::PRESSED);
} else if (cmd.req == CommandType::TOGGLE_DOOR_RELEASE) {
this->ratgdo_->received(ButtonState::RELEASED);
}
}
bool Secplus1::do_transmit_if_pending()
{
auto cmd = this->pop_pending_tx();
if (cmd) {
this->enqueue_command_pair(cmd.value());
this->transmit_byte(static_cast<uint32_t>(cmd.value()));
}
return cmd;
}
void Secplus1::enqueue_command_pair(CommandType cmd)
{
auto now = millis();
if (cmd == CommandType::TOGGLE_DOOR_PRESS) {
this->enqueue_transmit(CommandType::TOGGLE_DOOR_RELEASE, now + 500);
} else if (cmd == CommandType::TOGGLE_LIGHT_PRESS) {
this->enqueue_transmit(CommandType::TOGGLE_LIGHT_RELEASE, now + 500);
} else if (cmd == CommandType::TOGGLE_LOCK_PRESS) {
this->enqueue_transmit(CommandType::TOGGLE_LOCK_RELEASE, now + 3500);
};
}
void Secplus1::enqueue_transmit(CommandType cmd, uint32_t time)
{
if (time == 0) {
time = millis();
}
this->pending_tx_.push(TxCommand { cmd, time });
}
optional<CommandType> Secplus1::pending_tx()
{
if (this->pending_tx_.empty()) {
return {};
}
auto cmd = this->pending_tx_.top();
if (cmd.time > millis()) {
return {};
}
return cmd.request;
}
optional<CommandType> Secplus1::pop_pending_tx()
{
auto cmd = this->pending_tx();
if (cmd) {
this->pending_tx_.pop();
}
return cmd;
}
void Secplus1::transmit_byte(uint32_t value)
{
bool enable_rx = (value == 0x38) || (value == 0x39) || (value == 0x3A);
if (!enable_rx) {
this->sw_serial_.enableIntTx(false);
}
this->sw_serial_.write(value);
this->last_tx_ = millis();
if (!enable_rx) {
this->sw_serial_.enableIntTx(true);
}
ESP_LOG2(TAG, "[%d] Sent byte: [%02X]", millis(), value);
}
} // namespace secplus1
} // namespace ratgdo
} // namespace esphome

156
components/ratgdo/secplus1.h Normal file
View File

@ -0,0 +1,156 @@
#pragma once
#include <queue>
#include "SoftwareSerial.h" // Using espsoftwareserial https://github.com/plerup/espsoftwareserial
#include "esphome/core/optional.h"
#include "callbacks.h"
#include "observable.h"
#include "protocol.h"
#include "ratgdo_state.h"
namespace esphome {
class Scheduler;
class InternalGPIOPin;
namespace ratgdo {
namespace secplus1 {
using namespace esphome::ratgdo::protocol;
static const uint8_t RX_LENGTH = 2;
typedef uint8_t RxPacket[RX_LENGTH];
static const uint8_t TX_LENGTH = 2;
typedef uint8_t TxPacket[TX_LENGTH];
static const TxPacket toggle_door = { 0x30, 0x31 };
static const TxPacket toggle_light = { 0x32, 0x33 };
static const TxPacket toggle_lock = { 0x34, 0x35 };
static const uint8_t secplus1_states[] = { 0x35, 0x35, 0x35, 0x35, 0x33, 0x33, 0x53, 0x53, 0x38, 0x3A, 0x3A, 0x3A, 0x39, 0x38, 0x3A, 0x38, 0x3A, 0x39, 0x3A };
ENUM(CommandType, uint16_t,
(TOGGLE_DOOR_PRESS, 0x30),
(TOGGLE_DOOR_RELEASE, 0x31),
(TOGGLE_LIGHT_PRESS, 0x32),
(TOGGLE_LIGHT_RELEASE, 0x33),
(TOGGLE_LOCK_PRESS, 0x34),
(TOGGLE_LOCK_RELEASE, 0x35),
(QUERY_DOOR_STATUS_0x37, 0x37),
(QUERY_DOOR_STATUS, 0x38),
(OBSTRUCTION, 0x39),
(QUERY_OTHER_STATUS, 0x3A),
(UNKNOWN, 0xFF), )
struct RxCommand {
CommandType req;
uint8_t resp;
RxCommand()
: req(CommandType::UNKNOWN)
, resp(0)
{
}
RxCommand(CommandType req_)
: req(req_)
, resp(0)
{
}
RxCommand(CommandType req_, uint8_t resp_ = 0)
: req(req_)
, resp(resp_)
{
}
};
struct TxCommand {
CommandType request;
uint32_t time;
};
struct FirstToSend {
bool operator()(const TxCommand l, const TxCommand r) const { return l.time > r.time; }
};
enum class WallPanelEmulationState {
WAITING,
RUNNING,
};
class Secplus1 : public Protocol {
public:
void setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin);
void loop();
void dump_config();
void sync();
void light_action(LightAction action);
void lock_action(LockAction action);
void door_action(DoorAction action);
Result call(Args args);
const Traits& traits() const { return this->traits_; }
protected:
void wall_panel_emulation(size_t index = 0);
optional<RxCommand> read_command();
void handle_command(const RxCommand& cmd);
void print_rx_packet(const RxPacket& packet) const;
void print_tx_packet(const TxPacket& packet) const;
optional<RxCommand> decode_packet(const RxPacket& packet) const;
void enqueue_transmit(CommandType cmd, uint32_t time = 0);
optional<CommandType> pending_tx();
optional<CommandType> pop_pending_tx();
bool do_transmit_if_pending();
void enqueue_command_pair(CommandType cmd);
void transmit_byte(uint32_t value);
void toggle_light();
void toggle_lock();
void toggle_door();
void query_status();
LightState light_state { LightState::UNKNOWN };
LockState lock_state { LockState::UNKNOWN };
DoorState door_state { DoorState::UNKNOWN };
LightState maybe_light_state { LightState::UNKNOWN };
LockState maybe_lock_state { LockState::UNKNOWN };
DoorState maybe_door_state { DoorState::UNKNOWN };
OnceCallbacks<void(DoorState)> on_door_state_;
bool door_moving_ { false };
bool wall_panel_starting_ { false };
uint32_t wall_panel_emulation_start_ { 0 };
WallPanelEmulationState wall_panel_emulation_state_ { WallPanelEmulationState::WAITING };
bool is_0x37_panel_ { false };
std::priority_queue<TxCommand, std::vector<TxCommand>, FirstToSend> pending_tx_;
uint32_t last_rx_ { 0 };
uint32_t last_tx_ { 0 };
uint32_t last_status_query_ { 0 };
Traits traits_;
SoftwareSerial sw_serial_;
InternalGPIOPin* tx_pin_;
InternalGPIOPin* rx_pin_;
RATGDOComponent* ratgdo_;
Scheduler* scheduler_;
};
} // namespace secplus1
} // namespace ratgdo
} // namespace esphome

512
components/ratgdo/secplus2.cpp Normal file
View File

@ -0,0 +1,512 @@
#include "secplus2.h"
#include "ratgdo.h"
#include "esphome/core/gpio.h"
#include "esphome/core/log.h"
#include "esphome/core/scheduler.h"
extern "C" {
#include "secplus.h"
}
namespace esphome {
namespace ratgdo {
namespace secplus2 {
// MAX_CODES_WITHOUT_FLASH_WRITE is a bit of a guess
// since we write the flash at most every every 5s
//
// We want the rolling counter to be high enough that the
// GDO will accept the command after an unexpected reboot
// that did not save the counter to flash in time which
// results in the rolling counter being behind what the GDO
// expects.
static const uint8_t MAX_CODES_WITHOUT_FLASH_WRITE = 10;
static const char* const TAG = "ratgdo_secplus2";
void Secplus2::setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin)
{
this->ratgdo_ = ratgdo;
this->scheduler_ = scheduler;
this->tx_pin_ = tx_pin;
this->rx_pin_ = rx_pin;
this->sw_serial_.begin(9600, SWSERIAL_8N1, rx_pin->get_pin(), tx_pin->get_pin(), true);
this->sw_serial_.enableIntTx(false);
this->sw_serial_.enableAutoBaud(true);
this->traits_.set_features(Traits::all());
}
void Secplus2::loop()
{
if (this->transmit_pending_) {
if (!this->transmit_packet()) {
return;
}
}
auto cmd = this->read_command();
if (cmd) {
this->handle_command(*cmd);
}
}
void Secplus2::dump_config()
{
ESP_LOGCONFIG(TAG, " Rolling Code Counter: %d", *this->rolling_code_counter_);
ESP_LOGCONFIG(TAG, " Client ID: %d", this->client_id_);
ESP_LOGCONFIG(TAG, " Protocol: SEC+ v2");
}
void Secplus2::sync_helper(uint32_t start, uint32_t delay, uint8_t tries)
{
bool synced = true;
if (*this->ratgdo_->door_state == DoorState::UNKNOWN) {
this->query_status();
synced = false;
}
if (*this->ratgdo_->openings == 0) {
this->query_openings();
synced = false;
}
if (*this->ratgdo_->paired_total == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::ALL);
synced = false;
}
if (*this->ratgdo_->paired_remotes == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::REMOTE);
synced = false;
}
if (*this->ratgdo_->paired_keypads == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::KEYPAD);
synced = false;
}
if (*this->ratgdo_->paired_wall_controls == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::WALL_CONTROL);
synced = false;
}
if (*this->ratgdo_->paired_accessories == PAIRED_DEVICES_UNKNOWN) {
this->query_paired_devices(PairedDevice::ACCESSORY);
synced = false;
}
if (synced) {
return;
}
if (tries == 2 && *this->ratgdo_->door_state == DoorState::UNKNOWN) { // made a few attempts and no progress (door state is the first sync request)
// increment rolling code counter by some amount in case we crashed without writing to flash the latest value
this->increment_rolling_code_counter(MAX_CODES_WITHOUT_FLASH_WRITE);
}
// not sync-ed after 30s, notify failure
if (millis() - start > 30000) {
ESP_LOGW(TAG, "Triggering sync failed actions.");
this->ratgdo_->sync_failed = true;
} else {
if (tries % 3 == 0) {
delay *= 1.5;
}
this->scheduler_->set_timeout(this->ratgdo_, "sync", delay, [=]() {
this->sync_helper(start, delay, tries + 1);
});
};
}
void Secplus2::sync()
{
this->scheduler_->cancel_timeout(this->ratgdo_, "sync");
this->sync_helper(millis(), 500, 0);
}
void Secplus2::light_action(LightAction action)
{
if (action == LightAction::UNKNOWN) {
return;
}
this->send_command(Command(CommandType::LIGHT, static_cast<uint8_t>(action)));
}
void Secplus2::lock_action(LockAction action)
{
if (action == LockAction::UNKNOWN) {
return;
}
this->send_command(Command(CommandType::LOCK, static_cast<uint8_t>(action)));
}
void Secplus2::door_action(DoorAction action)
{
if (action == DoorAction::UNKNOWN) {
return;
}
this->door_command(action);
}
Result Secplus2::call(Args args)
{
using Tag = Args::Tag;
if (args.tag == Tag::query_status) {
this->send_command(CommandType::GET_STATUS);
} else if (args.tag == Tag::query_openings) {
this->send_command(CommandType::GET_OPENINGS);
} else if (args.tag == Tag::get_rolling_code_counter) {
return Result(RollingCodeCounter { std::addressof(this->rolling_code_counter_) });
} else if (args.tag == Tag::set_rolling_code_counter) {
this->set_rolling_code_counter(args.value.set_rolling_code_counter.counter);
} else if (args.tag == Tag::set_client_id) {
this->set_client_id(args.value.set_client_id.client_id);
} else if (args.tag == Tag::query_paired_devices) {
this->query_paired_devices(args.value.query_paired_devices.kind);
} else if (args.tag == Tag::query_paired_devices_all) {
this->query_paired_devices();
} else if (args.tag == Tag::clear_paired_devices) {
this->clear_paired_devices(args.value.clear_paired_devices.kind);
} else if (args.tag == Tag::activate_learn) {
this->activate_learn();
} else if (args.tag == Tag::inactivate_learn) {
this->inactivate_learn();
}
return {};
}
void Secplus2::door_command(DoorAction action)
{
this->send_command(Command(CommandType::DOOR_ACTION, static_cast<uint8_t>(action), 1, 1), IncrementRollingCode::NO, [=]() {
this->scheduler_->set_timeout(this->ratgdo_, "", 150, [=] {
this->send_command(Command(CommandType::DOOR_ACTION, static_cast<uint8_t>(action), 0, 1));
});
});
}
void Secplus2::query_status()
{
this->send_command(CommandType::GET_STATUS);
}
void Secplus2::query_openings()
{
this->send_command(CommandType::GET_OPENINGS);
}
void Secplus2::query_paired_devices()
{
const auto kinds = {
PairedDevice::ALL,
PairedDevice::REMOTE,
PairedDevice::KEYPAD,
PairedDevice::WALL_CONTROL,
PairedDevice::ACCESSORY
};
uint32_t timeout = 0;
for (auto kind : kinds) {
timeout += 200;
this->scheduler_->set_timeout(this->ratgdo_, "", timeout, [=] { this->query_paired_devices(kind); });
}
}
void Secplus2::query_paired_devices(PairedDevice kind)
{
ESP_LOGD(TAG, "Query paired devices of type: %s", PairedDevice_to_string(kind));
this->send_command(Command { CommandType::GET_PAIRED_DEVICES, static_cast<uint8_t>(kind) });
}
// wipe devices from memory based on get paired devices nibble values
void Secplus2::clear_paired_devices(PairedDevice kind)
{
if (kind == PairedDevice::UNKNOWN) {
return;
}
ESP_LOGW(TAG, "Clear paired devices of type: %s", PairedDevice_to_string(kind));
if (kind == PairedDevice::ALL) {
this->scheduler_->set_timeout(this->ratgdo_, "", 200, [=] { this->send_command(Command { CommandType::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::REMOTE) - 1 }); }); // wireless
this->scheduler_->set_timeout(this->ratgdo_, "", 400, [=] { this->send_command(Command { CommandType::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::KEYPAD) - 1 }); }); // keypads
this->scheduler_->set_timeout(this->ratgdo_, "", 600, [=] { this->send_command(Command { CommandType::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::WALL_CONTROL) - 1 }); }); // wall controls
this->scheduler_->set_timeout(this->ratgdo_, "", 800, [=] { this->send_command(Command { CommandType::CLEAR_PAIRED_DEVICES, static_cast<uint8_t>(PairedDevice::ACCESSORY) - 1 }); }); // accessories
this->scheduler_->set_timeout(this->ratgdo_, "", 1000, [=] { this->query_status(); });
this->scheduler_->set_timeout(this->ratgdo_, "", 1200, [=] { this->query_paired_devices(); });
} else {
uint8_t dev_kind = static_cast<uint8_t>(kind) - 1;
this->send_command(Command { CommandType::CLEAR_PAIRED_DEVICES, dev_kind }); // just requested device
this->scheduler_->set_timeout(this->ratgdo_, "", 200, [=] { this->query_status(); });
this->scheduler_->set_timeout(this->ratgdo_, "", 400, [=] { this->query_paired_devices(kind); });
}
}
// Learn functions
void Secplus2::activate_learn()
{
// Send LEARN with nibble = 0 then nibble = 1 to mimic wall control learn button
this->send_command(Command { CommandType::LEARN, 0 });
this->scheduler_->set_timeout(this->ratgdo_, "", 150, [=] { this->send_command(Command { CommandType::LEARN, 1 }); });
this->scheduler_->set_timeout(this->ratgdo_, "", 500, [=] { this->query_status(); });
}
void Secplus2::inactivate_learn()
{
// Send LEARN twice with nibble = 0 to inactivate learn and get status to update switch state
this->send_command(Command { CommandType::LEARN, 0 });
this->scheduler_->set_timeout(this->ratgdo_, "", 150, [=] { this->send_command(Command { CommandType::LEARN, 0 }); });
this->scheduler_->set_timeout(this->ratgdo_, "", 500, [=] { this->query_status(); });
}
optional<Command> Secplus2::read_command()
{
static bool reading_msg = false;
static uint32_t msg_start = 0;
static uint16_t byte_count = 0;
static WirePacket rx_packet;
static uint32_t last_read = 0;
if (!reading_msg) {
while (this->sw_serial_.available()) {
uint8_t ser_byte = this->sw_serial_.read();
last_read = millis();
if (ser_byte != 0x55 && ser_byte != 0x01 && ser_byte != 0x00) {
ESP_LOG2(TAG, "Ignoring byte (%d): %02X, baud: %d", byte_count, ser_byte, this->sw_serial_.baudRate());
byte_count = 0;
continue;
}
msg_start = ((msg_start << 8) | ser_byte) & 0xffffff;
byte_count++;
// if we are at the start of a message, capture the next 16 bytes
if (msg_start == 0x550100) {
ESP_LOG1(TAG, "Baud: %d", this->sw_serial_.baudRate());
rx_packet[0] = 0x55;
rx_packet[1] = 0x01;
rx_packet[2] = 0x00;
reading_msg = true;
break;
}
}
}
if (reading_msg) {
while (this->sw_serial_.available()) {
uint8_t ser_byte = this->sw_serial_.read();
last_read = millis();
rx_packet[byte_count] = ser_byte;
byte_count++;
// ESP_LOG2(TAG, "Received byte (%d): %02X, baud: %d", byte_count, ser_byte, this->sw_serial_.baudRate());
if (byte_count == PACKET_LENGTH) {
reading_msg = false;
byte_count = 0;
this->print_packet("Received packet: ", rx_packet);
return this->decode_packet(rx_packet);
}
}
if (millis() - last_read > 100) {
// if we have a partial packet and it's been over 100ms since last byte was read,
// the rest is not coming (a full packet should be received in ~20ms),
// discard it so we can read the following packet correctly
ESP_LOGW(TAG, "Discard incomplete packet, length: %d", byte_count);
reading_msg = false;
byte_count = 0;
}
}
return {};
}
void Secplus2::print_packet(const char* prefix, const WirePacket& packet) const
{
ESP_LOG2(TAG, "%s: [%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X]",
prefix,
packet[0],
packet[1],
packet[2],
packet[3],
packet[4],
packet[5],
packet[6],
packet[7],
packet[8],
packet[9],
packet[10],
packet[11],
packet[12],
packet[13],
packet[14],
packet[15],
packet[16],
packet[17],
packet[18]);
}
optional<Command> Secplus2::decode_packet(const WirePacket& packet) const
{
uint32_t rolling = 0;
uint64_t fixed = 0;
uint32_t data = 0;
decode_wireline(packet, &rolling, &fixed, &data);
uint16_t cmd = ((fixed >> 24) & 0xf00) | (data & 0xff);
data &= ~0xf000; // clear parity nibble
if ((fixed & 0xFFFFFFFF) == this->client_id_) { // my commands
ESP_LOG1(TAG, "[%ld] received mine: rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), rolling, fixed, data);
return {};
} else {
ESP_LOG1(TAG, "[%ld] received rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), rolling, fixed, data);
}
CommandType cmd_type = to_CommandType(cmd, CommandType::UNKNOWN);
uint8_t nibble = (data >> 8) & 0xff;
uint8_t byte1 = (data >> 16) & 0xff;
uint8_t byte2 = (data >> 24) & 0xff;
ESP_LOG1(TAG, "cmd=%03x (%s) byte2=%02x byte1=%02x nibble=%01x", cmd, CommandType_to_string(cmd_type), byte2, byte1, nibble);
return Command { cmd_type, nibble, byte1, byte2 };
}
void Secplus2::handle_command(const Command& cmd)
{
ESP_LOG1(TAG, "Handle command: %s", CommandType_to_string(cmd.type));
if (cmd.type == CommandType::STATUS) {
this->ratgdo_->received(to_DoorState(cmd.nibble, DoorState::UNKNOWN));
this->ratgdo_->received(to_LightState((cmd.byte2 >> 1) & 1, LightState::UNKNOWN));
this->ratgdo_->received(to_LockState((cmd.byte2 & 1), LockState::UNKNOWN));
// ESP_LOGD(TAG, "Obstruction: reading from byte2, bit2, status=%d", ((byte2 >> 2) & 1) == 1);
this->ratgdo_->received(to_ObstructionState((cmd.byte1 >> 6) & 1, ObstructionState::UNKNOWN));
this->ratgdo_->received(to_LearnState((cmd.byte2 >> 5) & 1, LearnState::UNKNOWN));
} else if (cmd.type == CommandType::LIGHT) {
this->ratgdo_->received(to_LightAction(cmd.nibble, LightAction::UNKNOWN));
} else if (cmd.type == CommandType::MOTOR_ON) {
this->ratgdo_->received(MotorState::ON);
} else if (cmd.type == CommandType::DOOR_ACTION) {
auto button_state = (cmd.byte1 & 1) == 1 ? ButtonState::PRESSED : ButtonState::RELEASED;
this->ratgdo_->received(button_state);
} else if (cmd.type == CommandType::MOTION) {
this->ratgdo_->received(MotionState::DETECTED);
} else if (cmd.type == CommandType::OPENINGS) {
this->ratgdo_->received(Openings { static_cast<uint16_t>((cmd.byte1 << 8) | cmd.byte2), cmd.nibble });
} else if (cmd.type == CommandType::SET_TTC) {
this->ratgdo_->received(TimeToClose { static_cast<uint16_t>((cmd.byte1 << 8) | cmd.byte2) });
} else if (cmd.type == CommandType::PAIRED_DEVICES) {
PairedDeviceCount pdc;
pdc.kind = to_PairedDevice(cmd.nibble, PairedDevice::UNKNOWN);
if (pdc.kind == PairedDevice::ALL) {
pdc.count = cmd.byte2;
} else if (pdc.kind == PairedDevice::REMOTE) {
pdc.count = cmd.byte2;
} else if (pdc.kind == PairedDevice::KEYPAD) {
pdc.count = cmd.byte2;
} else if (pdc.kind == PairedDevice::WALL_CONTROL) {
pdc.count = cmd.byte2;
} else if (pdc.kind == PairedDevice::ACCESSORY) {
pdc.count = cmd.byte2;
}
this->ratgdo_->received(pdc);
} else if (cmd.type == CommandType::BATTERY_STATUS) {
this->ratgdo_->received(to_BatteryState(cmd.byte1, BatteryState::UNKNOWN));
}
ESP_LOG1(TAG, "Done handle command: %s", CommandType_to_string(cmd.type));
}
void Secplus2::send_command(Command command, IncrementRollingCode increment)
{
ESP_LOG1(TAG, "Send command: %s, data: %02X%02X%02X", CommandType_to_string(command.type), command.byte2, command.byte1, command.nibble);
if (!this->transmit_pending_) { // have an untransmitted packet
this->encode_packet(command, this->tx_packet_);
if (increment == IncrementRollingCode::YES) {
this->increment_rolling_code_counter();
}
} else {
// unlikely this would happed (unless not connected to GDO), we're ensuring any pending packet
// is transmitted each loop before doing anyting else
if (this->transmit_pending_start_ > 0) {
ESP_LOGW(TAG, "Have untransmitted packet, ignoring command: %s", CommandType_to_string(command.type));
} else {
ESP_LOGW(TAG, "Not connected to GDO, ignoring command: %s", CommandType_to_string(command.type));
}
}
this->transmit_packet();
}
void Secplus2::send_command(Command command, IncrementRollingCode increment, std::function<void()>&& on_sent)
{
this->on_command_sent_(on_sent);
this->send_command(command, increment);
}
void Secplus2::encode_packet(Command command, WirePacket& packet)
{
auto cmd = static_cast<uint64_t>(command.type);
uint64_t fixed = ((cmd & ~0xff) << 24) | this->client_id_;
uint32_t data = (static_cast<uint64_t>(command.byte2) << 24) | (static_cast<uint64_t>(command.byte1) << 16) | (static_cast<uint64_t>(command.nibble) << 8) | (cmd & 0xff);
ESP_LOG2(TAG, "[%ld] Encode for transmit rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), *this->rolling_code_counter_, fixed, data);
encode_wireline(*this->rolling_code_counter_, fixed, data, packet);
}
bool Secplus2::transmit_packet()
{
auto now = micros();
while (micros() - now < 1300) {
if (this->rx_pin_->digital_read()) {
if (!this->transmit_pending_) {
this->transmit_pending_ = true;
this->transmit_pending_start_ = millis();
ESP_LOGD(TAG, "Collision detected, waiting to send packet");
} else {
if (millis() - this->transmit_pending_start_ < 5000) {
ESP_LOGD(TAG, "Collision detected, waiting to send packet");
} else {
this->transmit_pending_start_ = 0; // to indicate GDO not connected state
}
}
return false;
}
delayMicroseconds(100);
}
this->print_packet("Sending packet", this->tx_packet_);
// indicate the start of a frame by pulling the 12V line low for at leat 1 byte followed by
// one STOP bit, which indicates to the receiving end that the start of the message follows
// The output pin is controlling a transistor, so the logic is inverted
this->tx_pin_->digital_write(true); // pull the line low for at least 1 byte
delayMicroseconds(1300);
this->tx_pin_->digital_write(false); // line high for at least 1 bit
delayMicroseconds(130);
this->sw_serial_.write(this->tx_packet_, PACKET_LENGTH);
this->transmit_pending_ = false;
this->transmit_pending_start_ = 0;
this->on_command_sent_.trigger();
return true;
}
void Secplus2::increment_rolling_code_counter(int delta)
{
this->rolling_code_counter_ = (*this->rolling_code_counter_ + delta) & 0xfffffff;
}
void Secplus2::set_rolling_code_counter(uint32_t counter)
{
ESP_LOGV(TAG, "Set rolling code counter to %d", counter);
this->rolling_code_counter_ = counter;
}
void Secplus2::set_client_id(uint64_t client_id)
{
this->client_id_ = client_id & 0xFFFFFFFF;
}
} // namespace secplus2
} // namespace ratgdo
} // namespace esphome

154
components/ratgdo/secplus2.h Normal file
View File

@ -0,0 +1,154 @@
#pragma once
#include "SoftwareSerial.h" // Using espsoftwareserial https://github.com/plerup/espsoftwareserial
#include "esphome/core/optional.h"
#include "callbacks.h"
#include "common.h"
#include "observable.h"
#include "protocol.h"
#include "ratgdo_state.h"
namespace esphome {
class Scheduler;
class InternalGPIOPin;
namespace ratgdo {
class RATGDOComponent;
namespace secplus2 {
using namespace esphome::ratgdo::protocol;
static const uint8_t PACKET_LENGTH = 19;
typedef uint8_t WirePacket[PACKET_LENGTH];
ENUM(CommandType, uint16_t,
(UNKNOWN, 0x000),
(GET_STATUS, 0x080),
(STATUS, 0x081),
(OBST_1, 0x084), // sent when an obstruction happens?
(OBST_2, 0x085), // sent when an obstruction happens?
(BATTERY_STATUS, 0x09d),
(PAIR_3, 0x0a0),
(PAIR_3_RESP, 0x0a1),
(LEARN, 0x181),
(LOCK, 0x18c),
(DOOR_ACTION, 0x280),
(LIGHT, 0x281),
(MOTOR_ON, 0x284),
(MOTION, 0x285),
(GET_PAIRED_DEVICES, 0x307), // nibble 0 for total, 1 wireless, 2 keypads, 3 wall, 4 accessories.
(PAIRED_DEVICES, 0x308), // byte2 holds number of paired devices
(CLEAR_PAIRED_DEVICES, 0x30D), // nibble 0 to clear remotes, 1 keypads, 2 wall, 3 accessories (offset from above)
(LEARN_1, 0x391),
(PING, 0x392),
(PING_RESP, 0x393),
(PAIR_2, 0x400),
(PAIR_2_RESP, 0x401),
(SET_TTC, 0x402), // ttc_in_seconds = (byte1<<8)+byte2
(CANCEL_TTC, 0x408), // ?
(TTC, 0x40a), // Time to close
(GET_OPENINGS, 0x48b),
(OPENINGS, 0x48c), // openings = (byte1<<8)+byte2
)
inline bool operator==(const uint16_t cmd_i, const CommandType& cmd_e) { return cmd_i == static_cast<uint16_t>(cmd_e); }
inline bool operator==(const CommandType& cmd_e, const uint16_t cmd_i) { return cmd_i == static_cast<uint16_t>(cmd_e); }
enum class IncrementRollingCode {
NO,
YES,
};
struct Command {
CommandType type;
uint8_t nibble;
uint8_t byte1;
uint8_t byte2;
Command()
: type(CommandType::UNKNOWN)
{
}
Command(CommandType type_, uint8_t nibble_ = 0, uint8_t byte1_ = 0, uint8_t byte2_ = 0)
: type(type_)
, nibble(nibble_)
, byte1(byte1_)
, byte2(byte2_)
{
}
};
class Secplus2 : public Protocol {
public:
void setup(RATGDOComponent* ratgdo, Scheduler* scheduler, InternalGPIOPin* rx_pin, InternalGPIOPin* tx_pin);
void loop();
void dump_config();
void sync();
void light_action(LightAction action);
void lock_action(LockAction action);
void door_action(DoorAction action);
Result call(Args args);
const Traits& traits() const { return this->traits_; }
protected:
void increment_rolling_code_counter(int delta = 1);
void set_rolling_code_counter(uint32_t counter);
void set_client_id(uint64_t client_id);
optional<Command> read_command();
void handle_command(const Command& cmd);
void send_command(Command cmd, IncrementRollingCode increment = IncrementRollingCode::YES);
void send_command(Command cmd, IncrementRollingCode increment, std::function<void()>&& on_sent);
void encode_packet(Command cmd, WirePacket& packet);
bool transmit_packet();
void door_command(DoorAction action);
void query_status();
void query_openings();
void query_paired_devices();
void query_paired_devices(PairedDevice kind);
void clear_paired_devices(PairedDevice kind);
void activate_learn();
void inactivate_learn();
void print_packet(const char* prefix, const WirePacket& packet) const;
optional<Command> decode_packet(const WirePacket& packet) const;
void sync_helper(uint32_t start, uint32_t delay, uint8_t tries);
LearnState learn_state_ { LearnState::UNKNOWN };
observable<uint32_t> rolling_code_counter_ { 0 };
uint64_t client_id_ { 0x539 };
bool transmit_pending_ { false };
uint32_t transmit_pending_start_ { 0 };
WirePacket tx_packet_;
OnceCallbacks<void()> on_command_sent_;
Traits traits_;
SoftwareSerial sw_serial_;
InternalGPIOPin* tx_pin_;
InternalGPIOPin* rx_pin_;
RATGDOComponent* ratgdo_;
Scheduler* scheduler_;
};
} // namespace secplus2
} // namespace ratgdo
} // namespace esphome

1
components/ratgdo/sensor/__init__.py
View File

@ -38,4 +38,3 @@ async def to_code(config):
await cg.register_component(var, config)
cg.add(var.set_ratgdo_sensor_type(config[CONF_TYPE]))
await register_ratgdo_child(var, config)

2
components/ratgdo/switch/ratgdo_switch.cpp
View File

@ -19,7 +19,7 @@ namespace ratgdo {
{
if (this->switch_type_ == SwitchType::RATGDO_LEARN) {
this->parent_->subscribe_learn_state([=](LearnState state) {
this->publish_state(state==LearnState::ACTIVE);
this->publish_state(state == LearnState::ACTIVE);
});
}
}

52
static/index.html
View File

@ -154,15 +154,37 @@
<p>
Pick your board to flash your ratgdo board with ESPhome for <a href="https://paulwieland.github.io/ratgdo/">ratgdo</a>.
No programming or other software required.
<ul>
<li>Residential overhead mounted openers
<ul>
<li>with a yellow learn button are Security + 2.0</li>
<li>with a red, purple or orange learn button are Security + “1.0”</li>
</ul>
</li>
<li>Residential wall mounted jackshaft openers
<ul>
<li>With model 8500<strong>W</strong> or RJ070 are Security + 2.0</li>
<li>All others are Security + 1.0</li>
</ul>
</li>
<li>Security + 2.0 door openers require ratgdo v2.0 control board or later</li>
<li>Security + 1.0 &amp; Dry Contact door openers require v2.5 control board or later</li>
</ul>
</p>
<p><em>Note: At the moment ESPHome only supports Security + 2.0 door openers (Yellow learn button). Support for other protocols is coming.</em></p>
<p>
<em>
Security + 1.0 support is experimental and may not work for all openers. Dry contact support is coming soon.
</em>
</p>
<h3>v2.5i/2.52i Board</h3>
<h3>v2.5i/2.52i Board Security+ 2.0</h3>
<div class="radios">
<label>
<input type="radio" name="type" value="v25iboard" checked />
<img src="./v25iboard.png" alt="ratgdo v2.5i/2.52i board" />
<img src="./v25iboard.png" alt="ratgdo v2.5i/2.52i board with Security+ 2.0" />
</label>
</div>
<p>
@ -171,16 +193,24 @@
<li><a href="https://user-images.githubusercontent.com/4663918/277838851-e338c3bf-4eda-447a-9e79-737aa1a622a0.png">Version 2.5i Dry Contact Wiring Diagram</a></li>
</ul>
</p>
<h3>v2.5i/2.52i Board Security+ 1.0</h3>
<div class="radios">
<label>
<input type="radio" name="type" value="v25iboard_secplusv1" checked />
<img src="./v25iboard_secplusv1.png" alt="ratgdo v2.5i/2.52i board with Security+ 1.0" />
</label>
</div>
<h3>v2.5 Board</h3>
<h3>v2.5 Board Security+ 2.0</h3>
<div class="radios">
<label>
<input type="radio" name="type" value="v25board_esp8266_d1_mini_lite" />
<img src="./v25board_esp8266_d1_mini_lite.png" alt="ratgdo v2.5 board with ESP8266 D1 Mini Lite" />
<img src="./v25board_esp8266_d1_mini_lite.png" alt="ratgdo v2.5 board with ESP8266 D1 Mini Lite with Security+ 2.0" />
</label>
<label>
<input type="radio" name="type" value="v25board_esp32_d1_mini" />
<img src="./v25board_esp32_d1_mini.png" alt="ratgdo v2.5 board with ESP32 D1 Mini" />
<img src="./v25board_esp32_d1_mini.png" alt="ratgdo v2.5 board with ESP32 D1 Mini with Security+ 2.0" />
</label>
</div>
<p>
@ -190,23 +220,23 @@
</ul>
</p>
<h3>v2.0 Board</h3>
<h3>v2.0 Board Security+ 2.0</h3>
<div class="radios">
<label>
<input type="radio" name="type" value="v2board_esp8266_d1_mini_lite" />
<img src="./v2board_esp8266_d1_mini_lite.png" alt="ratgdo v2.0 board with ESP8266 D1 Mini Lite" />
<img src="./v2board_esp8266_d1_mini_lite.png" alt="ratgdo v2.0 board with ESP8266 D1 Mini Lite with Security+ 2.0" />
</label>
<label>
<input type="radio" name="type" value="v2board_esp8266_d1_mini" />
<img src="./v2board_esp8266_d1_mini.png" alt="ratgdo v2.0 board with ESP8266 D1 Mini" />
<img src="./v2board_esp8266_d1_mini.png" alt="ratgdo v2.0 board with ESP8266 D1 Mini with Security+ 2.0" />
</label>
<label>
<input type="radio" name="type" value="v2board_esp32_d1_mini" />
<img src="./v2board_esp32_d1_mini.png" alt="ratgdo v2.0 board with ESP32 D1 Mini" />
<img src="./v2board_esp32_d1_mini.png" alt="ratgdo v2.0 board with ESP32 D1 Mini with Security+ 2.0" />
</label>
<label>
<input type="radio" name="type" value="v2board_esp32_lolin_s2_mini" />
<img src="./v2board_esp32_lolin_s2_mini.png" alt="ratgdo v2.0 board with ESP32 lolin s2 mini" />
<img src="./v2board_esp32_lolin_s2_mini.png" alt="ratgdo v2.0 board with ESP32 lolin s2 mini with Security+ 2.0" />
</label>
</div>
<p>

BIN
static/v25iboard_secplusv1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 296 KiB

52
static/v25iboard_secplusv1.yaml Normal file
View File

@ -0,0 +1,52 @@
---
substitutions:
id_prefix: ratgdov25i
friendly_name: "ratgdov2.5i"
uart_tx_pin: D1
uart_rx_pin: D2
input_obst_pin: D7
status_door_pin: D0
status_obstruction_pin: D8
dry_contact_open_pin: D5
dry_contact_close_pin: D6
dry_contact_light_pin: D3
web_server:
esphome:
name: ${id_prefix}
friendly_name: ${friendly_name}
name_add_mac_suffix: true
project:
name: ratgdo.esphome
version: "2.5i"
esp8266:
board: d1_mini
restore_from_flash: true
dashboard_import:
package_import_url: github://ratgdo/esphome-ratgdo/v25iboard_secplusv1.yaml@main
packages:
remote_package:
url: https://github.com/ratgdo/esphome-ratgdo
files: [base_secplusv1.yaml]
refresh: 1s
# Sync time with Home Assistant.
time:
- platform: homeassistant
id: homeassistant_time
api:
id: api_server
ota:
improv_serial:
wifi:
ap:
logger:

1
v25iboard_secplusv1.yaml Symbolic link
View File

@ -0,0 +1 @@
static/v25iboard_secplusv1.yaml