sascha/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-09-21 04:32:23 +01:00
Code Issues Releases Wiki Activity

Add Alarm Control Panel (#4770)

Browse Source 
Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
This commit is contained in:
Graham Brown
2023-06-15 02:34:39 +02:00
committed by GitHub
parent 0411d52420
commit 54474e5b33
37 changed files with 1860 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
esphome/components/template/alarm_control_panel/__init__.py Normal file
View File

@@ -0,0 +1,123 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import (
binary_sensor,
alarm_control_panel,
)
from esphome.const import (
CONF_ID,
CONF_BINARY_SENSORS,
CONF_INPUT,
CONF_RESTORE_MODE,
)
from .. import template_ns
CODEOWNERS = ["@grahambrown11"]
CONF_CODES = "codes"
CONF_BYPASS_ARMED_HOME = "bypass_armed_home"
CONF_REQUIRES_CODE_TO_ARM = "requires_code_to_arm"
CONF_ARMING_HOME_TIME = "arming_home_time"
CONF_ARMING_AWAY_TIME = "arming_away_time"
CONF_PENDING_TIME = "pending_time"
CONF_TRIGGER_TIME = "trigger_time"
FLAG_NORMAL = "normal"
FLAG_BYPASS_ARMED_HOME = "bypass_armed_home"
BinarySensorFlags = {
FLAG_NORMAL: 1 << 0,
FLAG_BYPASS_ARMED_HOME: 1 << 1,
}
TemplateAlarmControlPanel = template_ns.class_(
"TemplateAlarmControlPanel", alarm_control_panel.AlarmControlPanel, cg.Component
)
TemplateAlarmControlPanelRestoreMode = template_ns.enum(
"TemplateAlarmControlPanelRestoreMode"
)
RESTORE_MODES = {
"ALWAYS_DISARMED": TemplateAlarmControlPanelRestoreMode.ALARM_CONTROL_PANEL_ALWAYS_DISARMED,
"RESTORE_DEFAULT_DISARMED": TemplateAlarmControlPanelRestoreMode.ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED,
}
def validate_config(config):
if config.get(CONF_REQUIRES_CODE_TO_ARM, False) and not config.get(CONF_CODES, []):
raise cv.Invalid(
f"{CONF_REQUIRES_CODE_TO_ARM} cannot be True when there are no codes."
)
return config
TEMPLATE_ALARM_CONTROL_PANEL_BINARY_SENSOR_SCHEMA = cv.maybe_simple_value(
{
cv.Required(CONF_INPUT): cv.use_id(binary_sensor.BinarySensor),
cv.Optional(CONF_BYPASS_ARMED_HOME, default=False): cv.boolean,
},
key=CONF_INPUT,
)
TEMPLATE_ALARM_CONTROL_PANEL_SCHEMA = (
alarm_control_panel.ALARM_CONTROL_PANEL_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(TemplateAlarmControlPanel),
cv.Optional(CONF_CODES): cv.ensure_list(cv.string_strict),
cv.Optional(CONF_REQUIRES_CODE_TO_ARM): cv.boolean,
cv.Optional(CONF_ARMING_HOME_TIME): cv.positive_time_period_milliseconds,
cv.Optional(
CONF_ARMING_AWAY_TIME, default="0s"
): cv.positive_time_period_milliseconds,
cv.Optional(
CONF_PENDING_TIME, default="0s"
): cv.positive_time_period_milliseconds,
cv.Optional(
CONF_TRIGGER_TIME, default="0s"
): cv.positive_time_period_milliseconds,
cv.Optional(CONF_BINARY_SENSORS): cv.ensure_list(
TEMPLATE_ALARM_CONTROL_PANEL_BINARY_SENSOR_SCHEMA
),
cv.Optional(CONF_RESTORE_MODE, default="ALWAYS_DISARMED"): cv.enum(
RESTORE_MODES, upper=True
),
}
).extend(cv.COMPONENT_SCHEMA)
)
CONFIG_SCHEMA = cv.All(
TEMPLATE_ALARM_CONTROL_PANEL_SCHEMA,
validate_config,
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await alarm_control_panel.register_alarm_control_panel(var, config)
if CONF_CODES in config:
for acode in config[CONF_CODES]:
cg.add(var.add_code(acode))
if CONF_REQUIRES_CODE_TO_ARM in config:
cg.add(var.set_requires_code_to_arm(config[CONF_REQUIRES_CODE_TO_ARM]))
cg.add(var.set_arming_away_time(config[CONF_ARMING_AWAY_TIME]))
cg.add(var.set_pending_time(config[CONF_PENDING_TIME]))
cg.add(var.set_trigger_time(config[CONF_TRIGGER_TIME]))
supports_arm_home = False
if CONF_ARMING_HOME_TIME in config:
cg.add(var.set_arming_home_time(config[CONF_ARMING_HOME_TIME]))
supports_arm_home = True
for sensor in config.get(CONF_BINARY_SENSORS, []):
bs = await cg.get_variable(sensor[CONF_INPUT])
flags = BinarySensorFlags[FLAG_NORMAL]
if sensor[CONF_BYPASS_ARMED_HOME]:
flags |= BinarySensorFlags[FLAG_BYPASS_ARMED_HOME]
supports_arm_home = True
cg.add(var.add_sensor(bs, flags))
cg.add(var.set_supports_arm_home(supports_arm_home))
cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))

180
esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp Normal file
View File

@@ -0,0 +1,180 @@
#include "template_alarm_control_panel.h"
#include <utility>
#include "esphome/components/alarm_control_panel/alarm_control_panel.h"
#include "esphome/core/application.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome {
namespace template_ {
using namespace esphome::alarm_control_panel;
static const char *const TAG = "template.alarm_control_panel";
TemplateAlarmControlPanel::TemplateAlarmControlPanel(){};
#ifdef USE_BINARY_SENSOR
void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor, uint16_t flags) {
this->sensor_map_[sensor] = flags;
};
#endif
void TemplateAlarmControlPanel::dump_config() {
ESP_LOGCONFIG(TAG, "TemplateAlarmControlPanel:");
ESP_LOGCONFIG(TAG, " Current State: %s", LOG_STR_ARG(alarm_control_panel_state_to_string(this->current_state_)));
ESP_LOGCONFIG(TAG, " Number of Codes: %u", this->codes_.size());
if (!this->codes_.empty())
ESP_LOGCONFIG(TAG, " Requires Code To Arm: %s", YESNO(this->requires_code_to_arm_));
ESP_LOGCONFIG(TAG, " Arming Away Time: %us", (this->arming_away_time_ / 1000));
if (this->arming_home_time_ != 0)
ESP_LOGCONFIG(TAG, " Arming Home Time: %us", (this->arming_home_time_ / 1000));
ESP_LOGCONFIG(TAG, " Pending Time: %us", (this->pending_time_ / 1000));
ESP_LOGCONFIG(TAG, " Trigger Time: %us", (this->trigger_time_ / 1000));
ESP_LOGCONFIG(TAG, " Supported Features: %u", this->get_supported_features());
#ifdef USE_BINARY_SENSOR
for (auto sensor_pair : this->sensor_map_) {
ESP_LOGCONFIG(TAG, " Binary Sesnsor:");
ESP_LOGCONFIG(TAG, " Name: %s", sensor_pair.first->get_name().c_str());
ESP_LOGCONFIG(TAG, " Armed home bypass: %s",
TRUEFALSE(sensor_pair.second & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME));
}
#endif
}
void TemplateAlarmControlPanel::setup() {
ESP_LOGCONFIG(TAG, "Setting up Template AlarmControlPanel '%s'...", this->name_.c_str());
switch (this->restore_mode_) {
case ALARM_CONTROL_PANEL_ALWAYS_DISARMED:
this->current_state_ = ACP_STATE_DISARMED;
break;
case ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED: {
uint8_t value;
this->pref_ = global_preferences->make_preference<uint8_t>(this->get_object_id_hash());
if (this->pref_.load(&value)) {
this->current_state_ = static_cast<alarm_control_panel::AlarmControlPanelState>(value);
} else {
this->current_state_ = ACP_STATE_DISARMED;
}
break;
}
}
this->desired_state_ = this->current_state_;
}
void TemplateAlarmControlPanel::loop() {
// change from ARMING to ARMED_x after the arming_time_ has passed
if (this->current_state_ == ACP_STATE_ARMING) {
auto delay = this->arming_away_time_;
if (this->desired_state_ == ACP_STATE_ARMED_HOME) {
delay = this->arming_home_time_;
}
if ((millis() - this->last_update_) > delay) {
this->publish_state(this->desired_state_);
}
return;
}
// change from PENDING to TRIGGERED after the delay_time_ has passed
if (this->current_state_ == ACP_STATE_PENDING && (millis() - this->last_update_) > this->pending_time_) {
this->publish_state(ACP_STATE_TRIGGERED);
return;
}
auto future_state = this->current_state_;
// reset triggered if all clear
if (this->current_state_ == ACP_STATE_TRIGGERED && this->trigger_time_ > 0 &&
(millis() - this->last_update_) > this->trigger_time_) {
future_state = this->desired_state_;
}
bool trigger = false;
#ifdef USE_BINARY_SENSOR
if (this->is_state_armed(future_state)) {
// TODO might be better to register change for each sensor in setup...
for (auto sensor_pair : this->sensor_map_) {
if (sensor_pair.first->state) {
if (this->current_state_ == ACP_STATE_ARMED_HOME &&
(sensor_pair.second & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME)) {
continue;
}
trigger = true;
break;
}
}
}
#endif
if (trigger) {
if (this->pending_time_ > 0 && this->current_state_ != ACP_STATE_TRIGGERED) {
this->publish_state(ACP_STATE_PENDING);
} else {
this->publish_state(ACP_STATE_TRIGGERED);
}
} else if (future_state != this->current_state_) {
this->publish_state(future_state);
}
}
bool TemplateAlarmControlPanel::is_code_valid_(optional<std::string> code) {
if (!this->codes_.empty()) {
if (code.has_value()) {
ESP_LOGVV(TAG, "Checking code: %s", code.value().c_str());
return (std::count(this->codes_.begin(), this->codes_.end(), code.value()) == 1);
}
ESP_LOGD(TAG, "No code provided");
return false;
}
return true;
}
uint32_t TemplateAlarmControlPanel::get_supported_features() const {
uint32_t features = ACP_FEAT_ARM_AWAY | ACP_FEAT_TRIGGER;
if (this->supports_arm_home_) {
features |= ACP_FEAT_ARM_HOME;
}
return features;
}
bool TemplateAlarmControlPanel::get_requires_code() const { return !this->codes_.empty(); }
void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_panel::AlarmControlPanelState state,
uint32_t delay) {
if (this->current_state_ != ACP_STATE_DISARMED) {
ESP_LOGW(TAG, "Cannot arm when not disarmed");
return;
}
if (this->requires_code_to_arm_ && !this->is_code_valid_(std::move(code))) {
ESP_LOGW(TAG, "Not arming code doesn't match");
return;
}
this->desired_state_ = state;
if (delay > 0) {
this->publish_state(ACP_STATE_ARMING);
} else {
this->publish_state(state);
}
}
void TemplateAlarmControlPanel::control(const AlarmControlPanelCall &call) {
if (call.get_state()) {
if (call.get_state() == ACP_STATE_ARMED_AWAY) {
this->arm_(call.get_code(), ACP_STATE_ARMED_AWAY, this->arming_away_time_);
} else if (call.get_state() == ACP_STATE_ARMED_HOME) {
this->arm_(call.get_code(), ACP_STATE_ARMED_HOME, this->arming_home_time_);
} else if (call.get_state() == ACP_STATE_DISARMED) {
if (!this->is_code_valid_(call.get_code())) {
ESP_LOGW(TAG, "Not disarming code doesn't match");
return;
}
this->desired_state_ = ACP_STATE_DISARMED;
this->publish_state(ACP_STATE_DISARMED);
} else if (call.get_state() == ACP_STATE_TRIGGERED) {
this->publish_state(ACP_STATE_TRIGGERED);
} else if (call.get_state() == ACP_STATE_PENDING) {
this->publish_state(ACP_STATE_PENDING);
} else {
ESP_LOGE(TAG, "State not yet implemented: %s",
LOG_STR_ARG(alarm_control_panel_state_to_string(*call.get_state())));
}
}
}
} // namespace template_
} // namespace esphome

116
esphome/components/template/alarm_control_panel/template_alarm_control_panel.h Normal file
View File

@@ -0,0 +1,116 @@
#pragma once
#include <map>
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/components/alarm_control_panel/alarm_control_panel.h"
#ifdef USE_BINARY_SENSOR
#include "esphome/components/binary_sensor/binary_sensor.h"
#endif
namespace esphome {
namespace template_ {
#ifdef USE_BINARY_SENSOR
enum BinarySensorFlags : uint16_t {
BINARY_SENSOR_MODE_NORMAL = 1 << 0,
BINARY_SENSOR_MODE_BYPASS_ARMED_HOME = 1 << 1,
};
#endif
enum TemplateAlarmControlPanelRestoreMode {
ALARM_CONTROL_PANEL_ALWAYS_DISARMED,
ALARM_CONTROL_PANEL_RESTORE_DEFAULT_DISARMED,
};
class TemplateAlarmControlPanel : public alarm_control_panel::AlarmControlPanel, public Component {
public:
TemplateAlarmControlPanel();
void dump_config() override;
void setup() override;
void loop() override;
uint32_t get_supported_features() const override;
bool get_requires_code() const override;
bool get_requires_code_to_arm() const override { return this->requires_code_to_arm_; }
void set_restore_mode(TemplateAlarmControlPanelRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
#ifdef USE_BINARY_SENSOR
/** Add a binary_sensor to the alarm_panel.
*
* @param sensor The BinarySensor instance.
* @param ignore_when_home if this should be ignored when armed_home mode
*/
void add_sensor(binary_sensor::BinarySensor *sensor, uint16_t flags = 0);
#endif
/** add a code
*
* @param code The code
*/
void add_code(const std::string &code) { this->codes_.push_back(code); }
/** set requires a code to arm
*
* @param code_to_arm The requires code to arm
*/
void set_requires_code_to_arm(bool code_to_arm) { this->requires_code_to_arm_ = code_to_arm; }
/** set the delay before arming away
*
* @param time The milliseconds
*/
void set_arming_away_time(uint32_t time) { this->arming_away_time_ = time; }
/** set the delay before arming home
*
* @param time The milliseconds
*/
void set_arming_home_time(uint32_t time) { this->arming_home_time_ = time; }
/** set the delay before triggering
*
* @param time The milliseconds
*/
void set_pending_time(uint32_t time) { this->pending_time_ = time; }
/** set the delay before resetting after triggered
*
* @param time The milliseconds
*/
void set_trigger_time(uint32_t time) { this->trigger_time_ = time; }
void set_supports_arm_home(bool supports_arm_home) { supports_arm_home_ = supports_arm_home; }
protected:
void control(const alarm_control_panel::AlarmControlPanelCall &call) override;
#ifdef USE_BINARY_SENSOR
// the map of binary sensors that the alarm_panel monitors with their modes
std::map<binary_sensor::BinarySensor *, uint16_t> sensor_map_;
#endif
TemplateAlarmControlPanelRestoreMode restore_mode_{};
// the arming away delay
uint32_t arming_away_time_;
// the arming home delay
uint32_t arming_home_time_{0};
// the trigger delay
uint32_t pending_time_;
// the time in trigger
uint32_t trigger_time_;
// a list of codes
std::vector<std::string> codes_;
// requires a code to arm
bool requires_code_to_arm_ = false;
bool supports_arm_home_ = false;
// check if the code is valid
bool is_code_valid_(optional<std::string> code);
void arm_(optional<std::string> code, alarm_control_panel::AlarmControlPanelState state, uint32_t delay);
};
} // namespace template_
} // namespace esphome