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

786 lines
29 KiB
C++
Raw Blame History

/************************************
* Rage
* Against
* The
* Garage
* Door
* Opener
*
* Copyright (C) 2022 Paul Wieland
*
* GNU GENERAL PUBLIC LICENSE
************************************/
#include "ratgdo.h"
#include "ratgdo_child.h"
#include "ratgdo_state.h"
#include "esphome/core/log.h"
namespace esphome {
namespace ratgdo {
static const char* const TAG = "ratgdo";
static const int SYNC_DELAY = 2000;
//
// 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 = 5;
static const uint32_t FLASH_WRITE_INTERVAL = 10000;
void IRAM_ATTR HOT RATGDOStore::isrObstruction(RATGDOStore* arg)
{
if (arg->input_obst.digital_read()) {
arg->lastObstructionHigh = millis();
} else {
arg->obstructionLowCount++;
}
}
void RATGDOComponent::setup()
{
this->rollingCodePref_ = global_preferences->make_preference<int>(734874333U);
if (!this->rollingCodePref_.load(&this->rollingCodeCounter)) {
this->rollingCodeCounter = 0;
}
this->openingDurationPref_ = global_preferences->make_preference<float>(734874334U);
if (!this->openingDurationPref_.load(&this->openingDuration)) {
this->setOpeningDuration(0);
} else {
this->sendOpeningDuration();
}
this->closingDurationPref_ = global_preferences->make_preference<float>(734874335U);
if (!this->closingDurationPref_.load(&this->closingDuration)) {
this->setClosingDuration(0.f);
} else {
this->sendClosingDuration();
}
this->output_gdo_pin_->setup();
this->input_gdo_pin_->setup();
this->input_obst_pin_->setup();
this->store_.input_obst = this->input_obst_pin_->to_isr();
this->output_gdo_pin_->pin_mode(gpio::FLAG_OUTPUT);
this->input_gdo_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
this->input_obst_pin_->pin_mode(gpio::FLAG_INPUT);
this->swSerial.begin(9600, SWSERIAL_8N1, this->input_gdo_pin_->get_pin(), this->output_gdo_pin_->get_pin(), true);
this->input_obst_pin_->attach_interrupt(RATGDOStore::isrObstruction, &this->store_, gpio::INTERRUPT_ANY_EDGE);
ESP_LOGV(TAG, "Syncing rolling code counter after reboot...");
// many things happening at startup, use some delay for sync
set_timeout(SYNC_DELAY, std::bind(&RATGDOComponent::sync, this));
}
void RATGDOComponent::loop()
{
obstructionLoop();
gdoStateLoop();
statusUpdateLoop();
}
void RATGDOComponent::dump_config()
{
ESP_LOGCONFIG(TAG, "Setting up RATGDO...");
LOG_PIN(" Output GDO Pin: ", this->output_gdo_pin_);
LOG_PIN(" Input GDO Pin: ", this->input_gdo_pin_);
LOG_PIN(" Input Obstruction Pin: ", this->input_obst_pin_);
ESP_LOGCONFIG(TAG, " Rolling Code Counter: %d", this->rollingCodeCounter);
ESP_LOGCONFIG(TAG, " Remote ID: %d", this->remote_id);
}
const char* cmd_name(uint16_t cmd)
{
// from: https://github.com/argilo/secplus/blob/f98c3220356c27717a25102c0b35815ebbd26ccc/secplus.py#L540
switch (cmd) {
// sent by opener (motor)
case 0x081:
return "status";
case 0x084:
return "unknown_1";
case 0x085:
return "unknown_2";
case 0x0a1:
return "pair_3_resp";
case 0x284:
return "motor_on";
case 0x393:
return "learn_3_resp";
case 0x401:
return "pair_2_resp";
case 0x48c:
return "openings";
// sent by switch
case 0x080:
return "get_status";
case 0x0a0:
return "pair_3";
case 0x181:
return "learn_2";
case 0x18c:
return "lock";
case 0x280:
return "open";
case 0x281:
return "light";
case 0x285:
return "motion";
case 0x391:
return "learn_1";
case 0x392:
return "learn_3";
case 0x400:
return "pair_2";
case 0x48b:
return "get_openings";
case 0x40a:
return "ttc"; // Time to close
default:
return "unknown";
}
}
uint16_t RATGDOComponent::readRollingCode()
{
uint32_t rolling = 0;
uint64_t fixed = 0;
uint32_t data = 0;
uint16_t cmd = 0;
uint8_t nibble = 0;
uint8_t byte1 = 0;
uint8_t byte2 = 0;
decode_wireline(this->rxRollingCode, &rolling, &fixed, &data);
cmd = ((fixed >> 24) & 0xf00) | (data & 0xff);
data &= ~0xf000; // clear parity nibble
if ((fixed & 0xfff) == this->remote_id) { // my commands
ESP_LOGD(TAG, "[%ld] received mine: rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), rolling, fixed, data);
return 0;
} else {
ESP_LOGD(TAG, "[%ld] received rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), rolling, fixed, data);
}
nibble = (data >> 8) & 0xff;
byte1 = (data >> 16) & 0xff;
byte2 = (data >> 24) & 0xff;
ESP_LOGD(TAG, "cmd=%03x (%s) byte2=%02x byte1=%02x nibble=%01x", cmd, cmd_name(cmd), byte2, byte1, nibble);
if (cmd == command::STATUS) {
this->doorState = static_cast<DoorState>(nibble);
if (this->doorState == DoorState::DOOR_STATE_OPENING && this->previousDoorState == DoorState::DOOR_STATE_CLOSED) {
this->startOpening = millis();
}
if (this->doorState == DoorState::DOOR_STATE_OPEN && this->previousDoorState == DoorState::DOOR_STATE_OPENING) {
if (this->startOpening > 0) {
auto duration = (millis() - this->startOpening) / 1000;
duration = this->openingDuration > 0 ? (duration + this->openingDuration) / 2 : duration;
this->setOpeningDuration(round(duration * 10) / 10);
}
}
if (this->doorState == DoorState::DOOR_STATE_CLOSING && this->previousDoorState == DoorState::DOOR_STATE_OPEN) {
this->startClosing = millis();
}
if (this->doorState == DoorState::DOOR_STATE_CLOSED && this->previousDoorState == DoorState::DOOR_STATE_CLOSING) {
if (this->startClosing > 0) {
auto duration = (millis() - this->startClosing) / 1000;
duration = this->closingDuration > 0 ? (duration + this->closingDuration) / 2 : duration;
this->setClosingDuration(round(duration * 10) / 10);
}
}
if (this->doorState == DoorState::DOOR_STATE_STOPPED) {
this->startOpening = -1;
this->startClosing = -1;
}
if (this->doorState == DoorState::DOOR_STATE_OPEN) {
this->doorPosition = 1.0;
} else if (this->doorState == DoorState::DOOR_STATE_CLOSED) {
this->doorPosition = 0.0;
} else {
if (this->closingDuration == 0 || this->openingDuration == 0 || this->doorPosition == DOOR_POSITION_UNKNOWN) {
this->doorPosition = 0.5; // best guess
}
}
if (this->doorState == DoorState::DOOR_STATE_OPENING && !this->movingToPosition) {
this->positionSyncWhileOpening(1.0 - this->doorPosition);
this->movingToPosition = true;
}
if (this->doorState == DoorState::DOOR_STATE_CLOSING && !this->movingToPosition) {
this->positionSyncWhileClosing(this->doorPosition);
this->movingToPosition = true;
}
if (this->doorState == DoorState::DOOR_STATE_OPEN || this->doorState == DoorState::DOOR_STATE_CLOSED || this->doorState == DoorState::DOOR_STATE_STOPPED) {
this->cancelPositionSyncCallbacks();
}
this->lightState = static_cast<LightState>((byte2 >> 1) & 1);
this->lockState = static_cast<LockState>(byte2 & 1);
this->motionState = MotionState::MOTION_STATE_CLEAR; // when the status message is read, reset motion state to 0|clear
this->motorState = MotorState::MOTOR_STATE_OFF; // when the status message is read, reset motor state to 0|off
// this->obstructionState = static_cast<ObstructionState>((byte1 >> 6) & 1);
if (this->doorState == DoorState::DOOR_STATE_CLOSED && this->doorState != this->previousDoorState) {
transmit(command::GET_OPENINGS);
}
ESP_LOGD(TAG, "Status: door=%s light=%s lock=%s",
door_state_to_string(this->doorState),
light_state_to_string(this->lightState),
lock_state_to_string(this->lockState));
} else if (cmd == command::LIGHT) {
if (nibble == 0) {
this->lightState = LightState::LIGHT_STATE_OFF;
} else if (nibble == 1) {
this->lightState = LightState::LIGHT_STATE_ON;
} else if (nibble == 2) { // toggle
this->lightState = light_state_toggle(this->lightState);
}
ESP_LOGD(TAG, "Light: action=%s state=%s",
nibble == 0 ? "OFF" : nibble == 1 ? "ON"
: "TOGGLE",
light_state_to_string(this->lightState));
} else if (cmd == command::MOTOR_ON) {
this->motorState = MotorState::MOTOR_STATE_ON;
ESP_LOGD(TAG, "Motor: state=%s", motor_state_to_string(this->motorState));
} else if (cmd == command::OPEN) {
this->buttonState = (byte1 & 1) == 1 ? ButtonState::BUTTON_STATE_PRESSED : ButtonState::BUTTON_STATE_RELEASED;
ESP_LOGD(TAG, "Open: button=%s", button_state_to_string(this->buttonState));
} else if (cmd == command::OPENINGS) {
this->openings = (byte1 << 8) | byte2;
ESP_LOGD(TAG, "Openings: %d", this->openings);
} else if (cmd == command::MOTION) {
this->motionState = MotionState::MOTION_STATE_DETECTED;
if (this->lightState == LightState::LIGHT_STATE_OFF) {
transmit(command::GET_STATUS);
}
ESP_LOGD(TAG, "Motion: %s", motion_state_to_string(this->motionState));
} else {
ESP_LOGD(TAG, "Unhandled command: cmd=%03x nibble=%02x byte1=%02x byte2=%02x fixed=%010" PRIx64 " data=%08" PRIx32, cmd, nibble, byte1, byte2, fixed, data);
}
return cmd;
}
void RATGDOComponent::getRollingCode(command::cmd command, uint32_t data, bool increment)
{
uint64_t fixed = ((command & ~0xff) << 24) | this->remote_id;
uint32_t send_data = (data << 8) | (command & 0xff);
ESP_LOGD(TAG, "[%ld] Encode for transmit rolling=%07" PRIx32 " fixed=%010" PRIx64 " data=%08" PRIx32, millis(), this->rollingCodeCounter, fixed, send_data);
encode_wireline(this->rollingCodeCounter, fixed, send_data, this->txRollingCode);
printRollingCode();
if (increment) {
incrementRollingCodeCounter();
}
}
void RATGDOComponent::setOpeningDuration(float duration)
{
ESP_LOGD(TAG, "Set opening duration: %.1fs", duration);
this->openingDuration = duration;
this->openingDurationPref_.save(&this->openingDuration);
sendOpeningDuration();
if (this->closingDuration == 0 && duration != 0) {
this->setClosingDuration(duration);
}
}
void RATGDOComponent::sendOpeningDuration()
{
for (auto* child : this->children_) {
child->on_opening_duration_change(this->openingDuration);
}
}
void RATGDOComponent::setClosingDuration(float duration)
{
ESP_LOGD(TAG, "Set closing duration: %.1fs", duration);
this->closingDuration = duration;
this->closingDurationPref_.save(&this->closingDuration);
sendClosingDuration();
if (this->openingDuration == 0 && duration != 0) {
this->setOpeningDuration(duration);
}
}
void RATGDOComponent::sendClosingDuration()
{
for (auto* child : this->children_) {
child->on_closing_duration_change(this->closingDuration);
}
}
void RATGDOComponent::setRollingCodeCounter(uint32_t counter)
{
ESP_LOGV(TAG, "Set rolling code counter to %d", counter);
this->rollingCodeCounter = counter;
this->rollingCodePref_.save(&this->rollingCodeCounter);
sendRollingCodeChanged();
}
void RATGDOComponent::incrementRollingCodeCounter()
{
this->rollingCodeCounter = (this->rollingCodeCounter + 1) & 0xfffffff;
sendRollingCodeChanged();
}
void RATGDOComponent::sendRollingCodeChanged()
{
if (!this->rollingCodeUpdatesEnabled_) {
return;
}
for (auto* child : this->children_) {
child->on_rolling_code_change(this->rollingCodeCounter);
}
}
void RATGDOComponent::printRollingCode()
{
ESP_LOGV(TAG, "Counter: %d Send code: [%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X]",
this->rollingCodeCounter,
this->txRollingCode[0],
this->txRollingCode[1],
this->txRollingCode[2],
this->txRollingCode[3],
this->txRollingCode[4],
this->txRollingCode[5],
this->txRollingCode[6],
this->txRollingCode[7],
this->txRollingCode[8],
this->txRollingCode[9],
this->txRollingCode[10],
this->txRollingCode[11],
this->txRollingCode[12],
this->txRollingCode[13],
this->txRollingCode[14],
this->txRollingCode[15],
this->txRollingCode[16],
this->txRollingCode[17],
this->txRollingCode[18]);
}
/*************************** OBSTRUCTION DETECTION ***************************/
void RATGDOComponent::obstructionLoop()
{
long currentMillis = millis();
static unsigned long lastMillis = 0;
// the obstruction sensor has 3 states: clear (HIGH with LOW pulse every 7ms), obstructed (HIGH), asleep (LOW)
// the transitions between awake and asleep are tricky because the voltage drops slowly when falling asleep
// and is high without pulses when waking up
// If at least 3 low pulses are counted within 50ms, the door is awake, not obstructed and we don't have to check anything else
// Every 50ms
if (currentMillis - lastMillis > 50) {
// check to see if we got between 3 and 8 low pulses on the line
if (this->store_.obstructionLowCount >= 3 && this->store_.obstructionLowCount <= 8) {
// obstructionCleared();
this->obstructionState = ObstructionState::OBSTRUCTION_STATE_CLEAR;
// if there have been no pulses the line is steady high or low
} else if (this->store_.obstructionLowCount == 0) {
// if the line is high and the last high pulse was more than 70ms ago, then there is an obstruction present
if (this->input_obst_pin_->digital_read() && currentMillis - this->store_.lastObstructionHigh > 70) {
this->obstructionState = ObstructionState::OBSTRUCTION_STATE_OBSTRUCTED;
// obstructionDetected();
} else {
// asleep
}
}
lastMillis = currentMillis;
this->store_.obstructionLowCount = 0;
}
}
void RATGDOComponent::gdoStateLoop()
{
static bool reading_msg = false;
static uint32_t msg_start = 0;
static uint16_t byte_count = 0;
if (!reading_msg) {
while (this->swSerial.available()) {
uint8_t ser_byte = this->swSerial.read();
if (ser_byte != 0x55 && ser_byte != 0x01 && ser_byte != 0x00) {
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) {
this->rxRollingCode[0] = 0x55;
this->rxRollingCode[1] = 0x01;
this->rxRollingCode[2] = 0x00;
reading_msg = true;
break;
}
}
}
if (reading_msg) {
while (this->swSerial.available()) {
uint8_t ser_byte = this->swSerial.read();
this->rxRollingCode[byte_count] = ser_byte;
byte_count++;
if (byte_count == CODE_LENGTH) {
reading_msg = false;
byte_count = 0;
if (readRollingCode() == command::STATUS && this->forceUpdate_) {
this->forceUpdate_ = false;
this->previousDoorState = DoorState::DOOR_STATE_UNKNOWN;
this->previousLightState = LightState::LIGHT_STATE_UNKNOWN;
this->previousLockState = LockState::LOCK_STATE_UNKNOWN;
}
return;
}
}
}
}
void RATGDOComponent::statusUpdateLoop()
{
if (this->doorState != this->previousDoorState) {
ESP_LOGV(TAG, "Door state: %s", door_state_to_string(this->doorState));
for (auto* child : this->children_) {
child->on_door_state(this->doorState, this->doorPosition);
}
this->previousDoorState = this->doorState;
}
if (this->doorPosition != this->previousDoorPosition) {
ESP_LOGV(TAG, "Door position: %f", this->doorPosition);
for (auto* child : this->children_) {
child->on_door_state(this->doorState, this->doorPosition);
}
this->previousDoorPosition = this->doorPosition;
}
if (this->lightState != this->previousLightState) {
ESP_LOGV(TAG, "Light state %s (%d)", light_state_to_string(this->lightState), this->lightState);
for (auto* child : this->children_) {
child->on_light_state(this->lightState);
}
this->previousLightState = this->lightState;
}
if (this->lockState != this->previousLockState) {
ESP_LOGV(TAG, "Lock state %s", lock_state_to_string(this->lockState));
for (auto* child : this->children_) {
child->on_lock_state(this->lockState);
}
this->previousLockState = this->lockState;
}
if (this->obstructionState != this->previousObstructionState) {
ESP_LOGV(TAG, "Obstruction state %s", obstruction_state_to_string(this->obstructionState));
for (auto* child : this->children_) {
child->on_obstruction_state(this->obstructionState);
}
this->previousObstructionState = this->obstructionState;
}
if (this->motorState != this->previousMotorState) {
ESP_LOGV(TAG, "Motor state %s", motor_state_to_string(this->motorState));
for (auto* child : this->children_) {
child->on_motor_state(this->motorState);
}
this->previousMotorState = this->motorState;
}
if (this->motionState != this->previousMotionState) {
ESP_LOGV(TAG, "Motion state %s", motion_state_to_string(this->motionState));
for (auto* child : this->children_) {
child->on_motion_state(this->motionState);
}
this->previousMotionState = this->motionState;
}
if (this->buttonState != this->previousButtonState) {
ESP_LOGV(TAG, "Button state %s", button_state_to_string(this->buttonState));
for (auto* child : this->children_) {
child->on_button_state(this->buttonState);
}
this->previousButtonState = this->buttonState;
}
if (this->openings != this->previousOpenings) {
ESP_LOGV(TAG, "Openings: %d", this->openings);
for (auto* child : this->children_) {
child->on_openings_change(this->openings);
}
this->previousOpenings = this->openings;
}
}
void RATGDOComponent::query_status()
{
this->forceUpdate_ = true;
transmit(command::GET_STATUS);
}
void RATGDOComponent::query_openings()
{
transmit(command::GET_OPENINGS);
}
/************************* DOOR COMMUNICATION *************************/
/*
* Transmit a message to the door opener over uart1
* The TX1 pin is controlling a transistor, so the logic is inverted
* A HIGH state on TX1 will pull the 12v line LOW
*
* The opener requires a specific duration low/high pulse before it will accept
* a message
*/
void RATGDOComponent::transmit(command::cmd command, uint32_t data, bool increment)
{
getRollingCode(command, data, increment);
this->output_gdo_pin_->digital_write(true); // pull the line high for 1305 micros so the
// door opener responds to the message
delayMicroseconds(1305);
this->output_gdo_pin_->digital_write(false); // bring the line low
delayMicroseconds(1260); // "LOW" pulse duration before the message start
this->swSerial.write(this->txRollingCode, CODE_LENGTH);
saveCounter();
}
void RATGDOComponent::sync()
{
if (this->rollingCodeCounter == 0) { // first time use
this->rollingCodeCounter = 1;
// the opener only sends a reply when the rolling code > previous rolling code for a given remote id
// when used the first time there is no previous rolling code, so first command is ignored
set_timeout(100, [=] {
transmit(command::GET_STATUS);
});
// send it twice since manual says it can take 3 button presses for door to open on first use
set_timeout(200, [=] {
transmit(command::GET_STATUS);
});
}
for (int i = 0; i <= MAX_CODES_WITHOUT_FLASH_WRITE; i++) {
set_timeout(300 + i * 100, [=] {
transmit(command::GET_STATUS);
});
}
set_timeout(400 + 100 * MAX_CODES_WITHOUT_FLASH_WRITE, [=] {
transmit(command::GET_OPENINGS);
});
}
void RATGDOComponent::openDoor()
{
if (this->doorState == DoorState::DOOR_STATE_OPENING) {
return; // gets ignored by opener
}
this->cancelPositionSyncCallbacks();
doorCommand(data::DOOR_OPEN);
}
void RATGDOComponent::closeDoor()
{
if (this->doorState == DoorState::DOOR_STATE_CLOSING || this->doorState == DoorState::DOOR_STATE_OPENING) {
return; // gets ignored by opener
}
this->cancelPositionSyncCallbacks();
doorCommand(data::DOOR_CLOSE);
}
void RATGDOComponent::stopDoor()
{
if (this->doorState != DoorState::DOOR_STATE_OPENING && this->doorState != DoorState::DOOR_STATE_CLOSING) {
ESP_LOGW(TAG, "The door is not moving.");
return;
}
doorCommand(data::DOOR_STOP);
}
void RATGDOComponent::toggleDoor()
{
if (this->doorState == DoorState::DOOR_STATE_OPENING) {
return; // gets ignored by opener
}
this->cancelPositionSyncCallbacks();
doorCommand(data::DOOR_TOGGLE);
}
void RATGDOComponent::positionSyncWhileOpening(float delta, float update_period)
{
if (this->openingDuration == 0) {
ESP_LOGW(TAG, "I don't know opening duration, ignoring position sync");
return;
}
auto updates = this->openingDuration * 1000 * delta / update_period;
auto position_update = delta / updates;
auto count = int(updates);
ESP_LOGD(TAG, "[Opening] Position sync %d times: ", count);
// try to keep position in sync while door is moving
set_retry("position_sync_while_moving", update_period, count, [=](uint8_t r) {
ESP_LOGD(TAG, "[Opening] Position sync: %d: ", r);
this->doorPosition += position_update;
return RetryResult::RETRY;
});
}
void RATGDOComponent::positionSyncWhileClosing(float delta, float update_period)
{
if (this->closingDuration == 0) {
ESP_LOGW(TAG, "I don't know closing duration, ignoring position sync");
return;
}
auto updates = this->closingDuration * 1000 * delta / update_period;
auto position_update = delta / updates;
auto count = int(updates);
ESP_LOGD(TAG, "[Closing] Position sync %d times: ", count);
// try to keep position in sync while door is moving
set_retry("position_sync_while_moving", update_period, count, [=](uint8_t r) {
ESP_LOGD(TAG, "[Closing] Position sync: %d: ", r);
this->doorPosition -= position_update;
return RetryResult::RETRY;
});
}
void RATGDOComponent::setDoorPosition(float position)
{
if (this->doorState == DoorState::DOOR_STATE_OPENING || this->doorState == DoorState::DOOR_STATE_CLOSING) {
ESP_LOGW(TAG, "The door is moving, ignoring.");
return;
}
auto delta = position - this->doorPosition;
if (delta == 0) {
ESP_LOGD(TAG, "Door is already at position %.2f", position);
return;
}
auto duration = delta > 0 ? this->openingDuration : this->closingDuration;
if (duration == 0) {
ESP_LOGW(TAG, "I don't know duration, ignoring move to position");
return;
}
if (delta > 0) { // open
doorCommand(data::DOOR_OPEN);
this->positionSyncWhileOpening(delta);
} else { // close
delta = -delta;
doorCommand(data::DOOR_CLOSE);
this->positionSyncWhileClosing(delta);
}
auto operation_time = duration * 1000 * delta;
ESP_LOGD(TAG, "Moving to position %.2f in %.1fs", position, operation_time / 1000.0)
this->movingToPosition = true;
set_timeout("move_to_position", operation_time, [=] {
doorCommand(data::DOOR_STOP);
this->movingToPosition = false;
this->doorPosition = position;
});
}
void RATGDOComponent::cancelPositionSyncCallbacks()
{
if (this->movingToPosition) {
ESP_LOGD(TAG, "Cancelling position callbacks");
cancel_timeout("move_to_position");
cancel_retry("position_sync_while_moving");
}
movingToPosition = false;
}
void RATGDOComponent::doorCommand(uint32_t data)
{
data |= (1 << 16); // button 1 ?
data |= (1 << 8); // button press
transmit(command::OPEN, data, false);
set_timeout(100, [=] {
auto data2 = data & ~(1 << 8); // button release
transmit(command::OPEN, data2);
});
}
void RATGDOComponent::lightOn()
{
this->lightState = LightState::LIGHT_STATE_ON;
transmit(command::LIGHT, data::LIGHT_ON);
}
void RATGDOComponent::lightOff()
{
this->lightState = LightState::LIGHT_STATE_OFF;
transmit(command::LIGHT, data::LIGHT_OFF);
}
void RATGDOComponent::toggleLight()
{
this->lightState = light_state_toggle(this->lightState);
transmit(command::LIGHT, data::LIGHT_TOGGLE);
}
// Lock functions
void RATGDOComponent::lock()
{
this->lockState = LockState::LOCK_STATE_LOCKED;
transmit(command::LOCK, data::LOCK_ON);
}
void RATGDOComponent::unlock()
{
transmit(command::LOCK, data::LOCK_OFF);
}
void RATGDOComponent::toggleLock()
{
this->lockState = lock_state_toggle(this->lockState);
transmit(command::LOCK, data::LOCK_TOGGLE);
}
void RATGDOComponent::saveCounter()
{
this->rollingCodePref_.save(&this->rollingCodeCounter);
// Forcing a sync results in a soft reset if there are too many
// writes to flash in a short period of time. To avoid this,
// we have configured preferences to write every 5s
}
void RATGDOComponent::register_child(RATGDOClient* obj)
{
this->children_.push_back(obj);
obj->set_parent(this);
}
LightState RATGDOComponent::getLightState()
{
return this->lightState;
}
} // namespace ratgdo
} // namespace esphome
Reference in New Issue View Git Blame Copy Permalink