def i2c_device_schema(default_address): """Create a schema for a i2c device. :param default_address: The default address of the i2c device, can be None to represent a required option. :return: The i2c device schema, `extend` this in your config schema. """ schema = { cv.GenerateID(CONF_I2C_ID): cv.use_id(I2CBus), cv.Optional("multiplexer"): cv.invalid( "This option has been removed, please see " "the tca9584a docs for the updated way to use multiplexers"), } if default_address is None: schema[cv.Required(CONF_ADDRESS)] = cv.i2c_address else: schema[cv.Optional(CONF_ADDRESS, default=default_address)] = cv.i2c_address return cv.Schema(schema)
import esphome.config_validation as cv CONFIG_SCHEMA = cv.invalid("This platform has been renamed to midea in 2021.9")
import esphome.config_validation as cv CONFIG_SCHEMA = cv.invalid( "This platform has been renamed to ble_presence in 1.13")
cv.Optional(CONF_ENABLE_MDNS, default=True): cv.boolean, cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name, cv.Optional(CONF_REBOOT_TIMEOUT, default="15min"): cv.positive_time_period_milliseconds, cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266="none", esp32="light"): cv.enum(WIFI_POWER_SAVE_MODES, upper=True), cv.Optional(CONF_FAST_CONNECT, default=False): cv.boolean, cv.Optional(CONF_USE_ADDRESS): cv.string_strict, cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0): cv.All(cv.decibel, cv.float_range(min=10.0, max=20.5)), cv.Optional("hostname"): cv.invalid("The hostname option has been removed in 1.11.0"), }), validate, ) def eap_auth(config): if config is None: return None ca_cert = "" if CONF_CERTIFICATE_AUTHORITY in config: ca_cert = wpa2_eap.read_relative_config_path( config[CONF_CERTIFICATE_AUTHORITY]) client_cert = "" if CONF_CERTIFICATE in config: client_cert = wpa2_eap.read_relative_config_path(
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import switch, ble_client from esphome.const import CONF_ICON, CONF_ID, CONF_INVERTED, ICON_BLUETOOTH from .. import ble_client_ns BLEClientSwitch = ble_client_ns.class_("BLEClientSwitch", switch.Switch, cg.Component, ble_client.BLEClientNode) CONFIG_SCHEMA = (switch.SWITCH_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(BLEClientSwitch), cv.Optional(CONF_INVERTED): cv.invalid("BLE client switches do not support inverted mode!"), cv.Optional(CONF_ICON, default=ICON_BLUETOOTH): switch.icon, }).extend(ble_client.BLE_CLIENT_SCHEMA).extend(cv.COMPONENT_SCHEMA)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await switch.register_switch(var, config) await ble_client.register_ble_node(var, config)
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." ), }) def validate_dumpers(value): if isinstance(value, str) and value.lower() == "all": return validate_dumpers(list(DUMPER_REGISTRY.keys())) return cv.validate_registry("dumper", DUMPER_REGISTRY)(value) def validate_triggers(base_schema): assert isinstance(base_schema, cv.Schema) @jschema_extractor("triggers") def validator(config):
cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds, cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds, }), cv.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MultiClickTrigger), cv.Required(CONF_TIMING): cv.All([parse_multi_click_timing_str], validate_multi_click_timing), cv.Optional(CONF_INVALID_COOLDOWN, default='1s'): cv.positive_time_period_milliseconds, }), cv.Optional(CONF_ON_STATE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger), }), cv.Optional(CONF_INVERTED): cv.invalid( "The inverted binary_sensor property has been replaced by the " "new 'invert' binary sensor filter. Please see " "https://esphome.io/components/binary_sensor/index.html." ), }) @coroutine def setup_binary_sensor_core_(var, config): cg.add(var.set_name(config[CONF_NAME])) if CONF_INTERNAL in config: cg.add(var.set_internal(CONF_INTERNAL)) if CONF_DEVICE_CLASS in config: cg.add(var.set_device_class(config[CONF_DEVICE_CLASS])) if CONF_INVERTED in config: cg.add(var.set_inverted(config[CONF_INVERTED])) if CONF_FILTERS in config:
def validate_data(value): if isinstance(value, text_type): return value.encode('utf-8') if isinstance(value, str): return value if isinstance(value, list): return cv.Schema([cv.hex_uint8_t])(value) raise vol.Invalid("data must either be a string wrapped in quotes or a list of bytes") PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(UARTSwitch), cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent), vol.Required(CONF_DATA): validate_data, vol.Optional(CONF_INVERTED): cv.invalid("UART switches do not support inverted mode!"), })) def to_code(config): for uart_ in get_variable(config[CONF_UART_ID]): yield data = config[CONF_DATA] if isinstance(data, str): data = [HexInt(ord(x)) for x in data] rhs = App.make_uart_switch(uart_, config[CONF_NAME], data) var = Pvariable(config[CONF_ID], rhs) switch.setup_switch(var, config) BUILD_FLAGS = '-DUSE_UART_SWITCH'
state_hex_schema, cv.Optional(CONF_COMMAND, default={}): command_hex_schema }) CONFIG_SCHEMA = fan.FAN_SCHEMA.extend({ cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(RS485Fan), cv.Optional(CONF_SPEED, default={}): cv.Schema({ cv.Optional(CONF_LOW): SPEED_SCHEMA, cv.Optional(CONF_MEDIUM): SPEED_SCHEMA, cv.Optional(CONF_HIGH): SPEED_SCHEMA }), cv.Optional(CONF_OUTPUT): cv.invalid("Not support output."), cv.Optional(CONF_OSCILLATION_OUTPUT): cv.invalid("Not support oscillation."), cv.Optional(CONF_DIRECTION_OUTPUT): cv.invalid("Not support direction.") }).extend(rs485.RS485_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA) async def to_code(config): var = cg.new_Pvariable(config[CONF_OUTPUT_ID]) await cg.register_component(var, config) await fan.register_fan(var, config) speeds = config[CONF_SPEED] if CONF_LOW in speeds: speed = speeds[CONF_LOW]
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import switch from esphome.const import CONF_ID, CONF_INVERTED, CONF_ICON, ICON_RESTART restart_ns = cg.esphome_ns.namespace("restart") RestartSwitch = restart_ns.class_("RestartSwitch", switch.Switch, cg.Component) CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(RestartSwitch), cv.Optional(CONF_INVERTED): cv.invalid("Restart switches do not support inverted mode!"), cv.Optional(CONF_ICON, default=ICON_RESTART): switch.icon, }).extend(cv.COMPONENT_SCHEMA) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield switch.register_switch(var, config)
cv.Optional(CONF_EAP): EAP_AUTH_SCHEMA, cv.Optional(CONF_AP): WIFI_NETWORK_AP, cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name, cv.Optional( CONF_REBOOT_TIMEOUT, default="15min" ): cv.positive_time_period_milliseconds, cv.SplitDefault( CONF_POWER_SAVE_MODE, esp8266="none", esp32="light" ): cv.enum(WIFI_POWER_SAVE_MODES, upper=True), cv.Optional(CONF_FAST_CONNECT, default=False): cv.boolean, cv.Optional(CONF_USE_ADDRESS): cv.string_strict, cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0): cv.All( cv.decibel, cv.float_range(min=10.0, max=20.5) ), cv.Optional("enable_mdns"): cv.invalid( "This option has been removed. Please use the [disabled] option under the " "new mdns component instead." ), } ), _validate, ) def eap_auth(config): if config is None: return None ca_cert = "" if CONF_CERTIFICATE_AUTHORITY in config: ca_cert = wpa2_eap.read_relative_config_path(config[CONF_CERTIFICATE_AUTHORITY]) client_cert = "" if CONF_CERTIFICATE in config:
vol.Required(CONF_COMMAND): vol.All(cv.hex_int, vol.Range(min=0, max=0x3F)), }), vol.Optional(CONF_RAW): validate_raw, vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA, vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA, vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA, vol.Optional(CONF_RC_SWITCH_TYPE_C): RC_SWITCH_TYPE_C_SCHEMA, vol.Optional(CONF_RC_SWITCH_TYPE_D): RC_SWITCH_TYPE_D_SCHEMA, vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, cv.Schema({ vol.Required(CONF_TIMES): cv.positive_not_null_int, vol.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds, })), cv.GenerateID(CONF_REMOTE_TRANSMITTER_ID): cv.use_variable_id(RemoteTransmitterComponent), cv.GenerateID(CONF_TRANSMITTER_ID): cv.declare_variable_id(RemoteTransmitter), vol.Optional(CONF_INVERTED): cv.invalid("Remote Transmitters do not support inverted mode!"), }), cv.has_exactly_one_key(*REMOTE_KEYS)) def transmitter_base(full_config): name = full_config[CONF_NAME] key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS) if key == CONF_JVC: return JVCTransmitter.new(name, config[CONF_DATA]) if key == CONF_LG: return LGTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS]) if key == CONF_NEC: return NECTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND]) if key == CONF_PANASONIC: return PanasonicTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
cv.int_range(min=1), cv.Optional(CONF_TX_PIN): pins.internal_gpio_output_pin_schema, cv.Optional(CONF_RX_PIN): validate_rx_pin, cv.Optional(CONF_RX_BUFFER_SIZE, default=256): cv.validate_bytes, cv.Optional(CONF_STOP_BITS, default=1): cv.one_of(1, 2, int=True), cv.Optional(CONF_DATA_BITS, default=8): cv.int_range(min=5, max=8), cv.Optional(CONF_PARITY, default="NONE"): cv.enum(UART_PARITY_OPTIONS, upper=True), cv.Optional(CONF_INVERT): cv.invalid( "This option has been removed. Please instead use invert in the tx/rx pin schemas." ), cv.Optional(CONF_DEBUG): maybe_empty_debug, }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN), ) async def debug_to_code(config, parent): trigger = cg.new_Pvariable(config[CONF_TRIGGER_ID], parent) await cg.register_component(trigger, config) for action in config[CONF_SEQUENCE]: await automation.build_automation( trigger, [(UARTDirection, "direction"),
FILTER_KEYS = [ CONF_INVERT, CONF_DELAYED_ON, CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT ] FILTERS_SCHEMA = cv.ensure_list( { vol.Optional(CONF_INVERT): None, vol.Optional(CONF_DELAYED_ON): cv.positive_time_period_milliseconds, vol.Optional(CONF_DELAYED_OFF): cv.positive_time_period_milliseconds, vol.Optional(CONF_LAMBDA): cv.lambda_, vol.Optional(CONF_HEARTBEAT): cv.invalid("The heartbeat filter has been removed in 1.11.0"), }, cv.has_exactly_one_key(*FILTER_KEYS)) MULTI_CLICK_TIMING_SCHEMA = vol.Schema({ vol.Optional(CONF_STATE): cv.boolean, vol.Optional(CONF_MIN_LENGTH): cv.positive_time_period_milliseconds, vol.Optional(CONF_MAX_LENGTH): cv.positive_time_period_milliseconds, }) def parse_multi_click_timing_str(value): if not isinstance(value, string_types): return value
SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).extend({ cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSensorComponent), cv.GenerateID(): cv.declare_id(Sensor), cv.Optional(CONF_UNIT_OF_MEASUREMENT): validate_unit_of_measurement, cv.Optional(CONF_ACCURACY_DECIMALS): validate_accuracy_decimals, cv.Optional(CONF_DEVICE_CLASS): validate_device_class, cv.Optional(CONF_STATE_CLASS): validate_state_class, cv.Optional("last_reset_type"): cv.invalid( "last_reset_type has been removed since 2021.9.0. state_class: total_increasing should be used for total values." ), cv.Optional(CONF_FORCE_UPDATE, default=False): cv.boolean, cv.Optional(CONF_EXPIRE_AFTER): cv.All( cv.requires_component("mqtt"), cv.Any(None, cv.positive_time_period_milliseconds), ), cv.Optional(CONF_FILTERS): validate_filters, cv.Optional(CONF_ON_VALUE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SensorStateTrigger), }),
raise cv.Invalid("Scan duration needs to be at least three times the scan interval to" "cover all BLE channels.") return config CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(ESP32BLETracker), cv.Optional(CONF_SCAN_PARAMETERS, default={}): cv.All(cv.Schema({ cv.Optional(CONF_DURATION, default='5min'): cv.positive_time_period_seconds, cv.Optional(CONF_INTERVAL, default='320ms'): cv.positive_time_period_milliseconds, cv.Optional(CONF_WINDOW, default='30ms'): cv.positive_time_period_milliseconds, cv.Optional(CONF_ACTIVE, default=True): cv.boolean, }), validate_scan_parameters), cv.Optional('scan_interval'): cv.invalid("This option has been removed in 1.14 (Reason: " "it never had an effect)"), }).extend(cv.COMPONENT_SCHEMA) ESP_BLE_DEVICE_SCHEMA = cv.Schema({ cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_id(ESP32BLETracker), }) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) params = config[CONF_SCAN_PARAMETERS] cg.add(var.set_scan_duration(params[CONF_DURATION])) cg.add(var.set_scan_interval(int(params[CONF_INTERVAL].total_milliseconds / 0.625))) cg.add(var.set_scan_window(int(params[CONF_WINDOW].total_milliseconds / 0.625))) cg.add(var.set_scan_active(params[CONF_ACTIVE]))
import esphome.codegen as cg import esphome.config_validation as cv from esphome import automation from esphome.components import binary_sensor, rs485 from esphome.const import CONF_ID from .. import rs485_ns from ..const import CONF_COMMAND_ON, CONF_COMMAND_OFF DEPENDENCIES = ['rs485'] RS485BinarySensor = rs485_ns.class_('RS485BinarySensor', binary_sensor.BinarySensor, cg.Component) CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(RS485BinarySensor), }).extend(rs485.RS485_DEVICE_SCHEMA).extend({ cv.Optional(CONF_COMMAND_ON): cv.invalid("RS485 Binary Sensor do not support command_on!"), cv.Optional(CONF_COMMAND_OFF): cv.invalid("RS485 Binary Sensor do not support command_off!") }).extend(cv.COMPONENT_SCHEMA) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await binary_sensor.register_binary_sensor(var, config) await rs485.register_rs485_device(var, config)
) from .. import speed_ns SpeedFan = speed_ns.class_("SpeedFan", cg.Component) CONFIG_SCHEMA = fan.FAN_SCHEMA.extend({ cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(SpeedFan), cv.Required(CONF_OUTPUT): cv.use_id(output.FloatOutput), cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_id(output.BinaryOutput), cv.Optional(CONF_DIRECTION_OUTPUT): cv.use_id(output.BinaryOutput), cv.Optional(CONF_SPEED): cv.invalid("Configuring individual speeds is deprecated."), cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1), }).extend(cv.COMPONENT_SCHEMA) def to_code(config): output_ = yield cg.get_variable(config[CONF_OUTPUT]) state = yield fan.create_fan_state(config) var = cg.new_Pvariable(config[CONF_OUTPUT_ID], state, output_, config[CONF_SPEED_COUNT]) yield cg.register_component(var, config) if CONF_OSCILLATION_OUTPUT in config: oscillation_output = yield cg.get_variable( config[CONF_OSCILLATION_OUTPUT])
cv.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema, validate_pin_number), cv.Optional(CONF_WAKEUP_PIN_MODE): cv.All(cv.only_on_esp32, cv.enum(WAKEUP_PIN_MODES), upper=True), cv.Optional(CONF_ESP32_EXT1_WAKEUP): cv.All( cv.only_on_esp32, cv.Schema({ cv.Required(CONF_PINS): cv.ensure_list(pins.shorthand_input_pin, validate_pin_number), cv.Required(CONF_MODE): cv.enum(EXT1_WAKEUP_MODES, upper=True), })), cv.Optional(CONF_RUN_CYCLES): cv.invalid("The run_cycles option has been removed in 1.11.0 as " "it was essentially the same as a run_duration of 0s." "Please use run_duration now.") }).extend(cv.COMPONENT_SCHEMA) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) if CONF_SLEEP_DURATION in config: cg.add(var.set_sleep_duration(config[CONF_SLEEP_DURATION])) if CONF_WAKEUP_PIN in config: pin = yield cg.gpio_pin_expression(config[CONF_WAKEUP_PIN]) cg.add(var.set_wakeup_pin(pin)) if CONF_WAKEUP_PIN_MODE in config: cg.add(var.set_wakeup_pin_mode(config[CONF_WAKEUP_PIN_MODE]))
return config CONFIG_SCHEMA = vol.All(cv.Schema({ cv.GenerateID(): cv.declare_variable_id(EthernetComponent), vol.Required(CONF_TYPE): cv.one_of(*ETHERNET_TYPES, upper=True), vol.Required(CONF_MDC_PIN): pins.output_pin, vol.Required(CONF_MDIO_PIN): pins.input_output_pin, vol.Optional(CONF_CLK_MODE, default='GPIO0_IN'): cv.one_of(*CLK_MODES, upper=True, space='_'), vol.Optional(CONF_PHY_ADDR, default=0): vol.All(cv.int_, vol.Range(min=0, max=31)), vol.Optional(CONF_POWER_PIN): pins.gpio_output_pin_schema, vol.Optional(CONF_MANUAL_IP): wifi.STA_MANUAL_IP_SCHEMA, vol.Optional(CONF_DOMAIN, default='.local'): cv.domain_name, vol.Optional(CONF_USE_ADDRESS): cv.string_strict, vol.Optional('hostname'): cv.invalid("The hostname option has been removed in 1.11.0"), }), validate) def to_code(config): rhs = App.init_ethernet() eth = Pvariable(config[CONF_ID], rhs) add(eth.set_phy_addr(config[CONF_PHY_ADDR])) add(eth.set_mdc_pin(config[CONF_MDC_PIN])) add(eth.set_mdio_pin(config[CONF_MDIO_PIN])) add(eth.set_type(ETHERNET_TYPES[config[CONF_TYPE]])) add(eth.set_clk_mode(CLK_MODES[config[CONF_CLK_MODE]])) add(eth.set_use_address(config[CONF_USE_ADDRESS])) if CONF_POWER_PIN in config:
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." ), } ) def validate_dumpers(value): if isinstance(value, str) and value.lower() == "all": return validate_dumpers(list(DUMPER_REGISTRY.keys())) return cv.validate_registry("dumper", DUMPER_REGISTRY)(value) def validate_triggers(base_schema): assert isinstance(base_schema, cv.Schema) @jschema_extractor("triggers")
CONF_OUTPUT_SOURCE_PRIORITY_UTILITY: ("POP00", None), CONF_OUTPUT_SOURCE_PRIORITY_SOLAR: ("POP01", None), CONF_OUTPUT_SOURCE_PRIORITY_BATTERY: ("POP02", None), CONF_INPUT_VOLTAGE_RANGE: ("PGR01", "PGR00"), CONF_PV_OK_CONDITION_FOR_PARALLEL: ("PPVOKC1", "PPVOKC0"), CONF_PV_POWER_BALANCE: ("PSPB1", "PSPB0"), } PipsolarSwitch = pipsolar_ns.class_("PipsolarSwitch", switch.Switch, cg.Component) PIPSWITCH_SCHEMA = switch.SWITCH_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(PipsolarSwitch), cv.Optional(CONF_INVERTED): cv.invalid("Pipsolar switches do not support inverted mode!"), cv.Optional(CONF_ICON, default=ICON_POWER): switch.icon, }).extend(cv.COMPONENT_SCHEMA) CONFIG_SCHEMA = PIPSOLAR_COMPONENT_SCHEMA.extend( {cv.Optional(type): PIPSWITCH_SCHEMA for type in TYPES}) async def to_code(config): paren = await cg.get_variable(config[CONF_PIPSOLAR_ID]) for type, (on, off) in TYPES.items(): if type in config: conf = config[type]
automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ShutdownTrigger), }), cv.Optional(CONF_ON_LOOP): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoopTrigger), }), cv.Optional(CONF_INCLUDES, default=[]): cv.ensure_list(valid_include), cv.Optional(CONF_LIBRARIES, default=[]): cv.ensure_list(cv.string_strict), cv.Optional('esphome_core_version'): cv.invalid("The esphome_core_version option has been " "removed in 1.13 - the esphome core source " "files are now bundled with ESPHome.") }) PRELOAD_CONFIG_SCHEMA = cv.Schema( { cv.Required(CONF_NAME): cv.valid_name, cv.Required(CONF_PLATFORM): validate_platform, }, extra=cv.ALLOW_EXTRA) PRELOAD_CONFIG_SCHEMA2 = PRELOAD_CONFIG_SCHEMA.extend({ cv.Required(CONF_BOARD): validate_board, cv.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string,
unit_of_measurement=UNIT_LUX, accuracy_decimals=1, device_class=DEVICE_CLASS_ILLUMINANCE, state_class=STATE_CLASS_MEASUREMENT, ) .extend( { cv.GenerateID(): cv.declare_id(BH1750Sensor), cv.Optional(CONF_RESOLUTION, default=0.5): cv.enum( BH1750_RESOLUTIONS, float=True ), cv.Optional(CONF_MEASUREMENT_DURATION, default=69): cv.int_range( min=31, max=254 ), cv.Optional(CONF_MEASUREMENT_TIME): cv.invalid( "The 'measurement_time' option has been replaced with 'measurement_duration' in 1.18.0" ), } ) .extend(cv.polling_component_schema("60s")) .extend(i2c.i2c_device_schema(0x23)) ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await sensor.register_sensor(var, config) await i2c.register_i2c_device(var, config) cg.add(var.set_resolution(config[CONF_RESOLUTION]))
ICON_ARROW_EXPAND_VERTICAL, 2, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ) .extend( { cv.GenerateID(): cv.declare_id(UltrasonicSensorComponent), cv.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema, cv.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema, cv.Optional(CONF_TIMEOUT, default="2m"): cv.distance, cv.Optional( CONF_PULSE_TIME, default="10us" ): cv.positive_time_period_microseconds, cv.Optional("timeout_meter"): cv.invalid( "The timeout_meter option has been renamed " "to 'timeout' in 1.12." ), cv.Optional("timeout_time"): cv.invalid( "The timeout_time option has been removed. Please " "use 'timeout' in 1.12." ), } ) .extend(cv.polling_component_schema("60s")) ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await sensor.register_sensor(var, config)
cv.Optional(CONF_MAC_ADDRESS): cv.mac_address, cv.Required(CONF_SERVICE_UUID): bt_uuid, }), cv.Optional(CONF_ON_BLE_MANUFACTURER_DATA_ADVERTISE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(BLEManufacturerDataAdvertiseTrigger), cv.Optional(CONF_MAC_ADDRESS): cv.mac_address, cv.Required(CONF_MANUFACTURER_ID): bt_uuid, }), cv.Optional('scan_interval'): cv.invalid("This option has been removed in 1.14 (Reason: " "it never had an effect)"), }).extend(cv.COMPONENT_SCHEMA) ESP_BLE_DEVICE_SCHEMA = cv.Schema({ cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_id(ESP32BLETracker), }) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) params = config[CONF_SCAN_PARAMETERS] cg.add(var.set_scan_duration(params[CONF_DURATION])) cg.add( var.set_scan_interval(
vol.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ShutdownTrigger), }), vol.Optional(CONF_ON_LOOP): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(LoopTrigger), }), vol.Optional(CONF_INCLUDES): cv.ensure_list(cv.file_), vol.Optional(CONF_LIBRARIES): cv.ensure_list(cv.string_strict), vol.Optional('esphomelib_version'): cv.invalid("The esphomelib_version has been renamed to " "esphome_core_version in 1.11.0"), }) def preload_core_config(config): if 'esphomeyaml' in config: _LOGGER.warning( "The esphomeyaml section has been renamed to esphome in 1.11.0. " "Please replace 'esphomeyaml:' in your configuration with 'esphome:'." ) config[CONF_ESPHOME] = config.pop('esphomeyaml') if CONF_ESPHOME not in config: raise EsphomeError(u"No esphome section in config") core_conf = config[CONF_ESPHOME] if CONF_PLATFORM not in core_conf: raise EsphomeError("esphome.platform not specified.")
DEPENDENCIES = ["i2c"] tca9548a_ns = cg.esphome_ns.namespace("tca9548a") TCA9548AComponent = tca9548a_ns.class_("TCA9548AComponent", cg.Component, i2c.I2CDevice) TCA9548AChannel = tca9548a_ns.class_("TCA9548AChannel", i2c.I2CBus) MULTI_CONF = True CONF_BUS_ID = "bus_id" CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(TCA9548AComponent), cv.Optional(CONF_SCAN): cv.invalid("This option has been removed"), cv.Optional(CONF_CHANNELS, default=[]): cv.ensure_list({ cv.Required(CONF_BUS_ID): cv.declare_id(TCA9548AChannel), cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=7), }), }).extend(i2c.i2c_device_schema(0x70)).extend(cv.COMPONENT_SCHEMA)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await i2c.register_i2c_device(var, config) for conf in config[CONF_CHANNELS]: chan = cg.new_Pvariable(conf[CONF_BUS_ID])
I2CDevice = pins.I2CDevice CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_variable_id(I2CComponent), vol.Optional(CONF_SDA, default='SDA'): pins.input_pin, vol.Optional(CONF_SCL, default='SCL'): pins.input_pin, vol.Optional(CONF_FREQUENCY): vol.All(cv.frequency, vol.Range(min=0, min_included=False)), vol.Optional(CONF_SCAN, default=True): cv.boolean, vol.Optional(CONF_RECEIVE_TIMEOUT): cv.invalid("The receive_timeout option has been removed " "because timeouts are already handled by the " "low-level i2c interface.") }).extend(cv.COMPONENT_SCHEMA.schema) def to_code(config): rhs = App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_SCAN)) i2c = Pvariable(config[CONF_ID], rhs) if CONF_FREQUENCY in config: add(i2c.set_frequency(config[CONF_FREQUENCY])) setup_component(i2c, config) BUILD_FLAGS = '-DUSE_I2C'
from esphome.components import switch, uart from esphome.const import CONF_DATA, CONF_ID, CONF_INVERTED from esphome.core import HexInt from .. import uart_ns, validate_raw_data DEPENDENCIES = ['uart'] UARTSwitch = uart_ns.class_('UARTSwitch', switch.Switch, uart.UARTDevice, cg.Component) CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(UARTSwitch), cv.Required(CONF_DATA): validate_raw_data, cv.Optional(CONF_INVERTED): cv.invalid("UART switches do not support inverted mode!"), }).extend(uart.UART_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield switch.register_switch(var, config) yield uart.register_uart_device(var, config) data = config[CONF_DATA] if isinstance(data, bytes): data = [HexInt(x) for x in data] cg.add(var.set_data(data))