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)