import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_ICON, ICON_KEY_PLUS
from . import CONF_FINGERPRINT_GROW_ID, FingerprintGrowComponent
DEPENDENCIES = ["fingerprint_grow"]
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema().extend({
cv.GenerateID(CONF_FINGERPRINT_GROW_ID):
cv.use_id(FingerprintGrowComponent),
cv.Optional(CONF_ICON, default=ICON_KEY_PLUS):
cv.icon,
})
async def to_code(config):
hub = await cg.get_variable(config[CONF_FINGERPRINT_GROW_ID])
var = await binary_sensor.new_binary_sensor(config)
cg.add(hub.set_enrolling_binary_sensor(var))
def validate_touch_pad(value):
value = gpio.validate_gpio_pin(value)
if value not in TOUCH_PADS:
raise cv.Invalid(f"Pin {value} does not support touch pads.")
return value
ESP32TouchBinarySensor = esp32_touch_ns.class_("ESP32TouchBinarySensor",
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(
ESP32TouchBinarySensor).extend({
cv.GenerateID(CONF_ESP32_TOUCH_ID):
cv.use_id(ESP32TouchComponent),
cv.Required(CONF_PIN):
validate_touch_pad,
cv.Required(CONF_THRESHOLD):
cv.uint16_t,
cv.Optional(CONF_WAKEUP_THRESHOLD, default=0):
cv.uint16_t,
})
async def to_code(config):
hub = await cg.get_variable(config[CONF_ESP32_TOUCH_ID])
var = cg.new_Pvariable(
config[CONF_ID],
TOUCH_PADS[config[CONF_PIN]],
config[CONF_THRESHOLD],
config[CONF_WAKEUP_THRESHOLD],
)
try:
x = int(x, 16)
except ValueError as err:
raise cv.Invalid(
"Valid characters for parts of a UID are 0123456789ABCDEF."
) from err
if x < 0 or x > 255:
raise cv.Invalid(
"Valid values for UID parts (separated by '-') are 00 to FF")
return value
PN532BinarySensor = pn532_ns.class_("PN532BinarySensor",
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(PN532BinarySensor).extend({
cv.GenerateID(CONF_PN532_ID):
cv.use_id(PN532),
cv.Required(CONF_UID):
validate_uid,
})
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
hub = await cg.get_variable(config[CONF_PN532_ID])
cg.add(hub.register_tag(var))
addr = [HexInt(int(x, 16)) for x in config[CONF_UID].split("-")]
cg.add(var.set_uid(addr))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_CHANNEL
from . import ttp229_lsf_ns, TTP229LSFComponent, CONF_TTP229_ID
DEPENDENCIES = ["ttp229_lsf"]
TTP229Channel = ttp229_lsf_ns.class_("TTP229Channel",
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(TTP229Channel).extend({
cv.GenerateID(CONF_TTP229_ID):
cv.use_id(TTP229LSFComponent),
cv.Required(CONF_CHANNEL):
cv.int_range(min=0, max=15),
})
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
cg.add(var.set_channel(config[CONF_CHANNEL]))
hub = await cg.get_variable(config[CONF_TTP229_ID])
cg.add(hub.register_channel(var))
return decorator
def declare_protocol(name):
data = ns.struct(f"{name}Data")
binary_sensor_ = ns.class_(f"{name}BinarySensor", RemoteReceiverBinarySensorBase)
trigger = ns.class_(f"{name}Trigger", RemoteReceiverTrigger)
action = ns.class_(f"{name}Action", RemoteTransmitterActionBase)
dumper = ns.class_(f"{name}Dumper", RemoteTransmitterDumper)
return data, binary_sensor_, trigger, action, dumper
BINARY_SENSOR_REGISTRY = Registry(
binary_sensor.binary_sensor_schema().extend(
{
cv.GenerateID(CONF_RECEIVER_ID): cv.use_id(RemoteReceiverBase),
}
)
)
validate_binary_sensor = cv.validate_registry_entry(
"remote receiver", BINARY_SENSOR_REGISTRY
)
TRIGGER_REGISTRY = SimpleRegistry()
DUMPER_REGISTRY = Registry(
{
cv.Optional(CONF_RECEIVER_ID): cv.invalid(
"This has been removed in ESPHome 1.20.0 and the dumper attaches directly to the parent receiver."
),
}
)
from esphome.components import binary_sensor
from esphome.const import (
CONF_DEVICE_CLASS,
CONF_ENTITY_CATEGORY,
CONF_ICON,
CONF_SOURCE_ID,
)
from esphome.core.entity_helpers import inherit_property_from
from .. import copy_ns
CopyBinarySensor = copy_ns.class_("CopyBinarySensor",
binary_sensor.BinarySensor, cg.Component)
CONFIG_SCHEMA = (binary_sensor.binary_sensor_schema(CopyBinarySensor).extend({
cv.Required(CONF_SOURCE_ID):
cv.use_id(binary_sensor.BinarySensor),
}).extend(cv.COMPONENT_SCHEMA))
FINAL_VALIDATE_SCHEMA = cv.All(
inherit_property_from(CONF_ICON, CONF_SOURCE_ID),
inherit_property_from(CONF_ENTITY_CATEGORY, CONF_SOURCE_ID),
inherit_property_from(CONF_DEVICE_CLASS, CONF_SOURCE_ID),
)
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
source = await cg.get_variable(config[CONF_SOURCE_ID])
cg.add(var.set_source(source))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_CHANNEL
from . import cap1188_ns, CAP1188Component, CONF_CAP1188_ID
DEPENDENCIES = ["cap1188"]
CAP1188Channel = cap1188_ns.class_("CAP1188Channel",
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(CAP1188Channel).extend({
cv.GenerateID(CONF_CAP1188_ID):
cv.use_id(CAP1188Component),
cv.Required(CONF_CHANNEL):
cv.int_range(min=0, max=7),
})
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
hub = await cg.get_variable(config[CONF_CAP1188_ID])
cg.add(var.set_channel(config[CONF_CHANNEL]))
cg.add(hub.register_channel(var))
{
cv.Optional(
CONF_BINARY_SENSORS,
default=[
{
CONF_NAME: "Demo Basement Floor Wet",
CONF_DEVICE_CLASS: DEVICE_CLASS_MOISTURE,
},
{
CONF_NAME: "Demo Movement Backyard",
CONF_DEVICE_CLASS: DEVICE_CLASS_MOTION,
},
],
): [
binary_sensor.binary_sensor_schema(DemoBinarySensor).extend(
cv.polling_component_schema("60s")
)
],
cv.Optional(
CONF_CLIMATES,
default=[
{
CONF_NAME: "Demo Heatpump",
CONF_TYPE: 1,
},
{
CONF_NAME: "Demo HVAC",
CONF_TYPE: 2,
},
{
CONF_NAME: "Demo Ecobee",
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from .. import SX1509Component, sx1509_ns, CONF_SX1509_ID
CONF_ROW = "row"
CONF_COL = "col"
DEPENDENCIES = ["sx1509"]
SX1509BinarySensor = sx1509_ns.class_("SX1509BinarySensor",
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(SX1509BinarySensor).extend({
cv.GenerateID(CONF_SX1509_ID):
cv.use_id(SX1509Component),
cv.Required(CONF_ROW):
cv.int_range(min=0, max=4),
cv.Required(CONF_COL):
cv.int_range(min=0, max=4),
})
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
hub = await cg.get_variable(config[CONF_SX1509_ID])
cg.add(var.set_row_col(config[CONF_ROW], config[CONF_COL]))
cg.add(hub.register_keypad_binary_sensor(var))
binary_sensor.BinarySensor,
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component,
)
CONFIG_SCHEMA = cv.All(
binary_sensor.binary_sensor_schema(XiaomiWX08ZM).extend({
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_TABLET):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
icon=ICON_BUG,
accuracy_decimals=0,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_BATTERY_LEVEL):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_BATTERY,
state_class=STATE_CLASS_MEASUREMENT,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
await esp32_ble_tracker.register_ble_device(var, config)
CONF_SKIP_UPDATES,
)
DEPENDENCIES = ["modbus_controller"]
CODEOWNERS = ["@martgras"]
ModbusBinarySensor = modbus_controller_ns.class_(
"ModbusBinarySensor", cg.Component, binary_sensor.BinarySensor, SensorItem
)
CONFIG_SCHEMA = cv.All(
binary_sensor.binary_sensor_schema(ModbusBinarySensor)
.extend(cv.COMPONENT_SCHEMA)
.extend(ModbusItemBaseSchema)
.extend(
{
cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
}
),
validate_modbus_register,
)
async def to_code(config):
byte_offset, _ = modbus_calc_properties(config)
var = cg.new_Pvariable(
config[CONF_ID],
config[CONF_REGISTER_TYPE],
config[CONF_ADDRESS],
byte_offset,
config[CONF_BITMASK],
from . import (
mpr121_ns,
MPR121Component,
CONF_MPR121_ID,
CONF_TOUCH_THRESHOLD,
CONF_RELEASE_THRESHOLD,
)
DEPENDENCIES = ["mpr121"]
MPR121Channel = mpr121_ns.class_("MPR121Channel", binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(MPR121Channel).extend({
cv.GenerateID(CONF_MPR121_ID):
cv.use_id(MPR121Component),
cv.Required(CONF_CHANNEL):
cv.int_range(min=0, max=11),
cv.Optional(CONF_TOUCH_THRESHOLD):
cv.int_range(min=0x05, max=0x30),
cv.Optional(CONF_RELEASE_THRESHOLD):
cv.int_range(min=0x05, max=0x30),
})
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
hub = await cg.get_variable(config[CONF_MPR121_ID])
cg.add(var.set_channel(config[CONF_CHANNEL]))
if CONF_TOUCH_THRESHOLD in config:
cg.add(var.set_touch_threshold(config[CONF_TOUCH_THRESHOLD]))
if CONF_RELEASE_THRESHOLD in config:
cg.add(var.set_release_threshold(config[CONF_RELEASE_THRESHOLD]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_ATTRIBUTE, CONF_ENTITY_ID
from .. import homeassistant_ns
DEPENDENCIES = ["api"]
HomeassistantBinarySensor = homeassistant_ns.class_(
"HomeassistantBinarySensor", binary_sensor.BinarySensor, cg.Component)
CONFIG_SCHEMA = (
binary_sensor.binary_sensor_schema(HomeassistantBinarySensor).extend({
cv.Required(CONF_ENTITY_ID):
cv.entity_id,
cv.Optional(CONF_ATTRIBUTE):
cv.string,
}).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))
if CONF_ATTRIBUTE in config:
cg.add(var.set_attribute(config[CONF_ATTRIBUTE]))
from esphome.components import binary_sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_SENSOR_DATAPOINT
from .. import tuya_ns, CONF_TUYA_ID, Tuya
DEPENDENCIES = ["tuya"]
CODEOWNERS = ["@jesserockz"]
TuyaBinarySensor = tuya_ns.class_("TuyaBinarySensor",
binary_sensor.BinarySensor, cg.Component)
CONFIG_SCHEMA = (binary_sensor.binary_sensor_schema(TuyaBinarySensor).extend({
cv.GenerateID(CONF_TUYA_ID):
cv.use_id(Tuya),
cv.Required(CONF_SENSOR_DATAPOINT):
cv.uint8_t,
}).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
paren = await cg.get_variable(config[CONF_TUYA_ID])
cg.add(var.set_tuya_parent(paren))
cg.add(var.set_sensor_id(config[CONF_SENSOR_DATAPOINT]))
CONF_FAULT_SELF_TEST_FAILED,
CONF_FAULT_OP_DC_VOLTAGE_OVER,
CONF_FAULT_BATTERY_OPEN,
CONF_FAULT_CURRENT_SENSOR_FAILED,
CONF_FAULT_BATTERY_SHORT,
CONF_WARNING_POWER_LIMIT,
CONF_WARNING_PV_VOLTAGE_HIGH,
CONF_FAULT_MPPT_OVERLOAD,
CONF_WARNING_MPPT_OVERLOAD,
CONF_WARNING_BATTERY_TOO_LOW_TO_CHARGE,
CONF_FAULT_DC_DC_OVER_CURRENT,
CONF_FAULT_CODE,
CONF_WARNUNG_LOW_PV_ENERGY,
CONF_WARNING_HIGH_AC_INPUT_DURING_BUS_SOFT_START,
CONF_WARNING_BATTERY_EQUALIZATION,
]
CONFIG_SCHEMA = PIPSOLAR_COMPONENT_SCHEMA.extend({
cv.Optional(type): binary_sensor.binary_sensor_schema()
for type in TYPES
})
async def to_code(config):
paren = await cg.get_variable(config[CONF_PIPSOLAR_ID])
for type in TYPES:
if type in config:
conf = config[type]
var = await binary_sensor.new_binary_sensor(conf)
cg.add(getattr(paren, f"set_{type}")(var))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_DIRECTION, DEVICE_CLASS_MOVING
from . import APDS9960, CONF_APDS9960_ID
DEPENDENCIES = ["apds9960"]
DIRECTIONS = {
"UP": "set_up_direction",
"DOWN": "set_down_direction",
"LEFT": "set_left_direction",
"RIGHT": "set_right_direction",
}
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(
device_class=DEVICE_CLASS_MOVING).extend({
cv.GenerateID(CONF_APDS9960_ID):
cv.use_id(APDS9960),
cv.Required(CONF_DIRECTION):
cv.one_of(*DIRECTIONS, upper=True),
})
async def to_code(config):
hub = await cg.get_variable(config[CONF_APDS9960_ID])
var = await binary_sensor.new_binary_sensor(config)
func = getattr(hub, DIRECTIONS[config[CONF_DIRECTION]])
cg.add(func(var))
DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_mue4094rt_ns = cg.esphome_ns.namespace("xiaomi_mue4094rt")
XiaomiMUE4094RT = xiaomi_mue4094rt_ns.class_(
"XiaomiMUE4094RT",
binary_sensor.BinarySensor,
cg.Component,
esp32_ble_tracker.ESPBTDeviceListener,
)
CONFIG_SCHEMA = cv.All(
binary_sensor.binary_sensor_schema(
XiaomiMUE4094RT, device_class=DEVICE_CLASS_MOTION).extend({
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_TIMEOUT, default="5s"):
cv.positive_time_period_milliseconds,
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
await esp32_ble_tracker.register_ble_device(var, config)
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
cg.add(var.set_time(config[CONF_TIMEOUT]))
from esphome.core import TimePeriod
from . import XiaomiRTCGQ02LM
DEPENDENCIES = ["xiaomi_rtcgq02lm"]
CONF_BUTTON = "button"
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.use_id(XiaomiRTCGQ02LM),
cv.Optional(CONF_MOTION):
binary_sensor.binary_sensor_schema(
device_class=DEVICE_CLASS_MOTION).extend({
cv.Optional(CONF_TIMEOUT, default="5s"):
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=TimePeriod(milliseconds=65535)),
),
}),
cv.Optional(CONF_LIGHT):
binary_sensor.binary_sensor_schema(device_class=DEVICE_CLASS_LIGHT),
cv.Optional(CONF_BUTTON):
binary_sensor.binary_sensor_schema().extend({
cv.Optional(CONF_TIMEOUT, default="200ms"):
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=TimePeriod(milliseconds=65535)),
),
}),
})
import esphome.codegen as cg
from esphome.components import binary_sensor
from .. import (
HOME_ASSISTANT_IMPORT_SCHEMA,
homeassistant_ns,
setup_home_assistant_entity,
)
DEPENDENCIES = ["api"]
HomeassistantBinarySensor = homeassistant_ns.class_(
"HomeassistantBinarySensor", binary_sensor.BinarySensor, cg.Component)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(
HomeassistantBinarySensor).extend(HOME_ASSISTANT_IMPORT_SCHEMA)
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
setup_home_assistant_entity(var, config)
from esphome.const import (
CONF_ID,
DEVICE_CLASS_COLD,
)
from . import hydreon_rgxx_ns, HydreonRGxxComponent
CONF_HYDREON_RGXX_ID = "hydreon_rgxx_id"
CONF_TOO_COLD = "too_cold"
HydreonRGxxBinarySensor = hydreon_rgxx_ns.class_("HydreonRGxxBinaryComponent",
cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(HydreonRGxxBinarySensor),
cv.GenerateID(CONF_HYDREON_RGXX_ID):
cv.use_id(HydreonRGxxComponent),
cv.Optional(CONF_TOO_COLD):
binary_sensor.binary_sensor_schema(device_class=DEVICE_CLASS_COLD),
})
async def to_code(config):
main_sensor = await cg.get_variable(config[CONF_HYDREON_RGXX_ID])
bin_component = cg.new_Pvariable(config[CONF_ID], main_sensor)
await cg.register_component(bin_component, config)
if CONF_TOO_COLD in config:
tc = await binary_sensor.new_binary_sensor(config[CONF_TOO_COLD])
cg.add(main_sensor.set_too_cold_sensor(tc))
CONF_CHARGING_MOS_ENABLED = "charging_mos_enabled"
CONF_DISCHARGING_MOS_ENABLED = "discharging_mos_enabled"
TYPES = [
CONF_CHARGING_MOS_ENABLED,
CONF_DISCHARGING_MOS_ENABLED,
]
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(CONF_BMS_DALY_ID): cv.use_id(DalyBmsComponent),
cv.Optional(
CONF_CHARGING_MOS_ENABLED
): binary_sensor.binary_sensor_schema(),
cv.Optional(
CONF_DISCHARGING_MOS_ENABLED
): binary_sensor.binary_sensor_schema(),
}
).extend(cv.COMPONENT_SCHEMA)
)
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
var = await binary_sensor.new_binary_sensor(conf)
cg.add(getattr(hub, f"set_{key}_binary_sensor")(var))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor, rdm6300
from esphome.const import CONF_UID
from . import rdm6300_ns
DEPENDENCIES = ["rdm6300"]
CONF_RDM6300_ID = "rdm6300_id"
RDM6300BinarySensor = rdm6300_ns.class_("RDM6300BinarySensor",
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(RDM6300BinarySensor).extend(
{
cv.GenerateID(CONF_RDM6300_ID): cv.use_id(rdm6300.RDM6300Component),
cv.Required(CONF_UID): cv.uint32_t,
})
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
hub = await cg.get_variable(config[CONF_RDM6300_ID])
cg.add(hub.register_card(var))
cg.add(var.set_id(config[CONF_UID]))
binary_sensor.binary_sensor_schema(
XiaomiMJYD02YLA, device_class=DEVICE_CLASS_MOTION).extend({
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Required(CONF_BINDKEY):
cv.bind_key,
cv.Optional(CONF_IDLE_TIME):
sensor.sensor_schema(
unit_of_measurement=UNIT_MINUTE,
icon=ICON_TIMELAPSE,
accuracy_decimals=0,
),
cv.Optional(CONF_BATTERY_LEVEL):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_BATTERY,
state_class=STATE_CLASS_MEASUREMENT,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
cv.Optional(CONF_ILLUMINANCE):
sensor.sensor_schema(
unit_of_measurement=UNIT_LUX,
accuracy_decimals=0,
device_class=DEVICE_CLASS_ILLUMINANCE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_LIGHT):
binary_sensor.binary_sensor_schema(
device_class=DEVICE_CLASS_LIGHT),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
cv.COMPONENT_SCHEMA))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from . import AS3935, CONF_AS3935_ID
DEPENDENCIES = ["as3935"]
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema().extend({
cv.GenerateID(CONF_AS3935_ID):
cv.use_id(AS3935),
})
async def to_code(config):
hub = await cg.get_variable(config[CONF_AS3935_ID])
var = await binary_sensor.new_binary_sensor(config)
cg.add(hub.set_thunder_alert_binary_sensor(var))
CONFIG_BINARY_SENSOR_SCHEMA,
CONF_VARIABLE_NAME,
CONF_COMPONENT_NAME,
)
CODEOWNERS = ["@senexcrenshaw"]
NextionBinarySensor = nextion_ns.class_("NextionBinarySensor",
binary_sensor.BinarySensor,
cg.PollingComponent)
CONFIG_SCHEMA = cv.All(
binary_sensor.binary_sensor_schema(NextionBinarySensor).extend({
cv.Optional(CONF_PAGE_ID):
cv.uint8_t,
cv.Optional(CONF_COMPONENT_ID):
cv.uint8_t,
}).extend(CONFIG_BINARY_SENSOR_SCHEMA).extend(
cv.polling_component_schema("never")),
cv.has_at_least_one_key(
CONF_PAGE_ID,
CONF_COMPONENT_ID,
CONF_COMPONENT_NAME,
CONF_VARIABLE_NAME,
),
)
async def to_code(config):
hub = await cg.get_variable(config[CONF_NEXTION_ID])
var = cg.new_Pvariable(config[CONF_ID], hub)
def validate_xpt2046_button(config):
if cv.int_(config[CONF_X_MAX]) < cv.int_(config[CONF_X_MIN]) or cv.int_(
config[CONF_Y_MAX]) < cv.int_(config[CONF_Y_MIN]):
raise cv.Invalid(
"x_max is less than x_min or y_max is less than y_min")
return config
CONFIG_SCHEMA = cv.All(
binary_sensor.binary_sensor_schema(XPT2046Button).extend({
cv.GenerateID(CONF_XPT2046_ID):
cv.use_id(XPT2046Component),
cv.Required(CONF_X_MIN):
cv.int_range(min=0, max=4095),
cv.Required(CONF_X_MAX):
cv.int_range(min=0, max=4095),
cv.Required(CONF_Y_MIN):
cv.int_range(min=0, max=4095),
cv.Required(CONF_Y_MAX):
cv.int_range(min=0, max=4095),
}),
validate_xpt2046_button,
)
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
hub = await cg.get_variable(config[CONF_XPT2046_ID])
cg.add(
var.set_area(
config[CONF_X_MIN],
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import binary_sensor
from esphome.const import CONF_PIN
from .. import gpio_ns
GPIOBinarySensor = gpio_ns.class_(
"GPIOBinarySensor", binary_sensor.BinarySensor, cg.Component
)
CONFIG_SCHEMA = (
binary_sensor.binary_sensor_schema(GPIOBinarySensor)
.extend(
{
cv.Required(CONF_PIN): pins.gpio_input_pin_schema,
}
)
.extend(cv.COMPONENT_SCHEMA)
)
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
pin = await cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.components import binary_sensor
from esphome.const import CONF_ID, CONF_LAMBDA, CONF_STATE
from .. import template_ns
TemplateBinarySensor = template_ns.class_("TemplateBinarySensor",
binary_sensor.BinarySensor,
cg.Component)
CONFIG_SCHEMA = (
binary_sensor.binary_sensor_schema(TemplateBinarySensor).extend({
cv.Optional(CONF_LAMBDA):
cv.returning_lambda,
}).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
if CONF_LAMBDA in config:
template_ = await cg.process_lambda(
config[CONF_LAMBDA], [], return_type=cg.optional.template(bool))
cg.add(var.set_template(template_))
@automation.register_action(
"binary_sensor.template.publish",
binary_sensor.BinarySensorPublishAction,
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import (
DEVICE_CLASS_CONNECTIVITY,
ENTITY_CATEGORY_DIAGNOSTIC,
)
status_ns = cg.esphome_ns.namespace("status")
StatusBinarySensor = status_ns.class_("StatusBinarySensor",
binary_sensor.BinarySensor, cg.Component)
CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(
StatusBinarySensor,
device_class=DEVICE_CLASS_CONNECTIVITY,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA
from .. import custom_ns
CustomBinarySensorConstructor = custom_ns.class_(
"CustomBinarySensorConstructor")
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(CustomBinarySensorConstructor),
cv.Required(CONF_LAMBDA):
cv.returning_lambda,
cv.Required(CONF_BINARY_SENSORS):
cv.ensure_list(binary_sensor.binary_sensor_schema()),
})
async def to_code(config):
template_ = await cg.process_lambda(
config[CONF_LAMBDA],
[],
return_type=cg.std_vector.template(binary_sensor.BinarySensorPtr),
)
rhs = CustomBinarySensorConstructor(template_)
custom = cg.variable(config[CONF_ID], rhs)
for i, conf in enumerate(config[CONF_BINARY_SENSORS]):
rhs = custom.Pget_binary_sensor(i)
await binary_sensor.register_binary_sensor(rhs, conf)
