def validate_cron_keys(value): if CONF_CRON in value: for key in value.keys(): if key in CRON_KEYS: raise vol.Invalid( "Cannot use option {} when cron: is specified.".format( key)) cron_ = value[CONF_CRON] value = {x: value[x] for x in value if x != CONF_CRON} value.update(cron_) return value return cv.has_at_least_one_key(*CRON_KEYS)(value)
def validate_cron_keys(value): if CONF_CRON in value: for key in value.keys(): if key in CRON_KEYS: raise cv.Invalid(f"Cannot use option {key} when cron: is specified.") if CONF_AT in value: raise cv.Invalid("Cannot use option at with cron!") cron_ = value[CONF_CRON] value = {x: value[x] for x in value if x != CONF_CRON} value.update(cron_) return value if CONF_AT in value: for key in value.keys(): if key in CRON_KEYS: raise cv.Invalid(f"Cannot use option {key} when at: is specified.") at_ = value[CONF_AT] value = {x: value[x] for x in value if x != CONF_AT} value.update(at_) return value return cv.has_at_least_one_key(*CRON_KEYS)(value)
{ cv.Required(CONF_URL): cv.url, cv.Optional(CONF_USERNAME): cv.string, cv.Optional(CONF_PASSWORD): cv.string, cv.Exclusive(CONF_FILE, "files"): validate_yaml_filename, cv.Exclusive(CONF_FILES, "files"): cv.All( cv.ensure_list(validate_yaml_filename), cv.Length(min=1), ), cv.Optional(CONF_REF): cv.git_ref, cv.Optional(CONF_REFRESH, default="1d"): cv.All( cv.string, cv.source_refresh ), } ), cv.has_at_least_one_key(CONF_FILE, CONF_FILES), ) CONFIG_SCHEMA = cv.All( cv.Schema( { str: cv.Any(validate_source_shorthand, BASE_SCHEMA, dict), } ), validate_git_package, ) def _process_base_package(config: dict) -> dict: repo_dir = git.clone_or_update(
automation.validate_automation(single=True), cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature, cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature, cv.Optional(CONF_HYSTERESIS, default=0.5): cv.temperature, cv.Optional(CONF_AWAY_CONFIG): cv.Schema({ cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature, cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature, }), }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_COOL_ACTION, CONF_DRY_ACTION, CONF_FAN_ONLY_ACTION, CONF_HEAT_ACTION), validate_thermostat) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield climate.register_climate(var, config) auto_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config two_points_available = CONF_HEAT_ACTION in config and ( CONF_COOL_ACTION in config or CONF_FAN_ONLY_ACTION in config) sens = yield cg.get_variable(config[CONF_SENSOR]) cg.add(var.set_sensor(sens)) cg.add(var.set_hysteresis(config[CONF_HYSTERESIS]))
cv.percentage, cv.Optional(CONF_RED, default=1.0): cv.percentage, cv.Optional(CONF_GREEN, default=1.0): cv.percentage, cv.Optional(CONF_BLUE, default=1.0): cv.percentage, cv.Optional(CONF_WHITE, default=1.0): cv.percentage, cv.Required(CONF_DURATION): cv.positive_time_period_milliseconds, }), cv.has_at_least_one_key( CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE, CONF_WHITE, ), ), cv.Length(min=2), ), }, ) def strobe_effect_to_code(config, effect_id): var = cg.new_Pvariable(effect_id, config[CONF_NAME]) colors = [] for color in config.get(CONF_COLORS, []): colors.append( cg.StructInitializer( StrobeLightEffectColor,
cv.temperature, cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True), cv.Optional(CONF_COOL_ACTION): automation.validate_automation(single=True), cv.Optional(CONF_HEAT_ACTION): automation.validate_automation(single=True), cv.Optional(CONF_AWAY_CONFIG): cv.Schema({ cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature, cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature, }), }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_COOL_ACTION, CONF_HEAT_ACTION)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield climate.register_climate(var, config) sens = yield cg.get_variable(config[CONF_SENSOR]) cg.add(var.set_sensor(sens)) normal_config = BangBangClimateTargetTempConfig( config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW], config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH]) cg.add(var.set_normal_config(normal_config))
cv.uint8_t, cv.Optional(CONF_SWITCH_DATAPOINT): cv.uint8_t, cv.Optional(CONF_MIN_VALUE): cv.int_, cv.Optional(CONF_MAX_VALUE): cv.int_, # Change the default gamma_correct and default transition length settings. # The Tuya MCU handles transitions and gamma correction on its own. cv.Optional(CONF_GAMMA_CORRECT, default=1.0): cv.positive_float, cv.Optional(CONF_DEFAULT_TRANSITION_LENGTH, default='0s'): cv.positive_time_period_milliseconds, }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_DIMMER_DATAPOINT, CONF_SWITCH_DATAPOINT)) def to_code(config): var = cg.new_Pvariable(config[CONF_OUTPUT_ID]) yield cg.register_component(var, config) yield light.register_light(var, config) if CONF_DIMMER_DATAPOINT in config: cg.add(var.set_dimmer_id(config[CONF_DIMMER_DATAPOINT])) if CONF_MIN_VALUE_DATAPOINT in config: cg.add(var.set_min_value_datapoint_id( config[CONF_MIN_VALUE_DATAPOINT])) if CONF_SWITCH_DATAPOINT in config: cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT])) if CONF_MIN_VALUE in config:
})), vol.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(INA219VoltageSensor), })), vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(INA219CurrentSensor), })), vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(INA219PowerSensor), })), vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1): vol.All(cv.resistance, vol.Range(min=0.0, max=32.0)), vol.Optional(CONF_MAX_VOLTAGE, default=32.0): vol.All(cv.voltage, vol.Range(min=0.0, max=32.0)), vol.Optional(CONF_MAX_CURRENT, default=3.2): vol.All(cv.current, vol.Range(min=0.0)), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS)) def to_code(config): rhs = App.make_ina219(config[CONF_SHUNT_RESISTANCE], config[CONF_MAX_CURRENT], config[CONF_MAX_VOLTAGE], config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL)) ina = Pvariable(config[CONF_ID], rhs) if CONF_BUS_VOLTAGE in config: conf = config[CONF_BUS_VOLTAGE] sensor.register_sensor(ina.Pmake_bus_voltage_sensor(conf[CONF_NAME]), conf) if CONF_SHUNT_VOLTAGE in config: conf = config[CONF_SHUNT_VOLTAGE] sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(conf[CONF_NAME]), conf) if CONF_CURRENT in config: conf = config[CONF_CURRENT]
cv.Optional(CONF_UV): sensor.sensor_schema( unit_of_measurement=UNIT_COUNTS, icon=ICON_BRIGHTNESS_5, accuracy_decimals=1, device_class=DEVICE_CLASS_ILLUMINANCE, ), cv.Optional(CONF_GAIN, default="X3"): cv.enum(GAIN_OPTIONS), cv.Optional(CONF_RESOLUTION, default=18): cv.enum(RES_OPTIONS), cv.Optional(CONF_WINDOW_CORRECTION_FACTOR, default=1.0): cv.float_range(min=1.0), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x53)), cv.has_at_least_one_key(CONF_LIGHT, CONF_AMBIENT_LIGHT, CONF_UV_INDEX, CONF_UV), ) TYPES = { CONF_LIGHT: "set_light_sensor", CONF_AMBIENT_LIGHT: "set_als_sensor", CONF_UV_INDEX: "set_uvi_sensor", CONF_UV: "set_uv_sensor", } 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)
DEPENDENCIES = ['tuya'] CONF_SPEED_DATAPOINT = "speed_datapoint" CONF_SWITCH_DATAPOINT = "switch_datapoint" CONF_OSCILLATION_DATAPOINT = "oscillation_datapoint" TuyaFan = tuya_ns.class_('TuyaFan', cg.Component) CONFIG_SCHEMA = cv.All(fan.FAN_SCHEMA.extend({ cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(TuyaFan), cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya), cv.Optional(CONF_OSCILLATION_DATAPOINT): cv.uint8_t, cv.Optional(CONF_SPEED_DATAPOINT): cv.uint8_t, cv.Optional(CONF_SWITCH_DATAPOINT): cv.uint8_t, }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key( CONF_SPEED_DATAPOINT, CONF_SWITCH_DATAPOINT)) def to_code(config): var = cg.new_Pvariable(config[CONF_OUTPUT_ID]) yield cg.register_component(var, config) paren = yield cg.get_variable(config[CONF_TUYA_ID]) fan_ = yield fan.create_fan_state(config) cg.add(var.set_tuya_parent(paren)) cg.add(var.set_fan(fan_)) if CONF_SPEED_DATAPOINT in config: cg.add(var.set_speed_id(config[CONF_SPEED_DATAPOINT])) if CONF_SWITCH_DATAPOINT in config: cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT]))
await cg.register_component(var, {}) template_ = await cg.templatable(config, args, cg.uint32) cg.add(var.set_delay(template_)) return var @register_action( "if", IfAction, cv.All( { cv.Required(CONF_CONDITION): validate_potentially_and_condition, cv.Optional(CONF_THEN): validate_action_list, cv.Optional(CONF_ELSE): validate_action_list, }, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE), ), ) async def if_action_to_code(config, action_id, template_arg, args): conditions = await build_condition(config[CONF_CONDITION], template_arg, args) var = cg.new_Pvariable(action_id, template_arg, conditions) if CONF_THEN in config: actions = await build_action_list(config[CONF_THEN], template_arg, args) cg.add(var.add_then(actions)) if CONF_ELSE in config: actions = await build_action_list(config[CONF_ELSE], template_arg, args) cg.add(var.add_else(actions)) return var
cv.Optional(CONF_COLOR_TEMPERATURE_MAX_VALUE): cv.int_, cv.Inclusive(CONF_COLD_WHITE_COLOR_TEMPERATURE, "color_temperature"): cv.color_temperature, cv.Inclusive(CONF_WARM_WHITE_COLOR_TEMPERATURE, "color_temperature"): cv.color_temperature, # Change the default gamma_correct and default transition length settings. # The Tuya MCU handles transitions and gamma correction on its own. cv.Optional(CONF_GAMMA_CORRECT, default=1.0): cv.positive_float, cv.Optional(CONF_DEFAULT_TRANSITION_LENGTH, default="0s"): cv.positive_time_period_milliseconds, }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key( CONF_DIMMER_DATAPOINT, CONF_SWITCH_DATAPOINT, CONF_RGB_DATAPOINT, CONF_HSV_DATAPOINT, ), ) async def to_code(config): var = cg.new_Pvariable(config[CONF_OUTPUT_ID]) await cg.register_component(var, config) await light.register_light(var, config) if CONF_DIMMER_DATAPOINT in config: cg.add(var.set_dimmer_id(config[CONF_DIMMER_DATAPOINT])) if CONF_MIN_VALUE_DATAPOINT in config: cg.add(var.set_min_value_datapoint_id( config[CONF_MIN_VALUE_DATAPOINT]))
@CONDITION_REGISTRY.register(CONF_OR, OR_CONDITION_SCHEMA) def or_condition_to_code(config, condition_id, template_arg, args): for conditions in build_conditions(config, template_arg, args): yield rhs = OrCondition.new(template_arg, conditions) type = OrCondition.template(template_arg) yield Pvariable(condition_id, rhs, type=type) RANGE_CONDITION_SCHEMA = vol.All( cv.Schema({ vol.Optional(CONF_ABOVE): cv.templatable(cv.float_), vol.Optional(CONF_BELOW): cv.templatable(cv.float_), }), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)) @CONDITION_REGISTRY.register(CONF_RANGE, RANGE_CONDITION_SCHEMA) def range_condition_to_code(config, condition_id, template_arg, args): for conditions in build_conditions(config, template_arg, args): yield rhs = RangeCondition.new(template_arg, conditions) type = RangeCondition.template(template_arg) condition = Pvariable(condition_id, rhs, type=type) if CONF_ABOVE in config: for template_ in templatable(config[CONF_ABOVE], args, float_): yield condition.set_min(template_) if CONF_BELOW in config: for template_ in templatable(config[CONF_BELOW], args, float_):
cv.Optional(CONF_IIR_FILTER, default="OFF"): cv.enum(IIR_FILTER_OPTIONS, upper=True), cv.Optional(CONF_HEATER): cv.Any( None, cv.All( cv.Schema({ cv.Optional(CONF_TEMPERATURE, default=320): cv.int_range(min=200, max=400), cv.Optional(CONF_DURATION, default="150ms"): cv.All( cv.positive_time_period_milliseconds, cv.Range(max=core.TimePeriod(milliseconds=4032)), ), }), cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION), ), ), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x76))) 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) if CONF_TEMPERATURE in config: conf = config[CONF_TEMPERATURE] sens = await sensor.new_sensor(conf) cg.add(var.set_temperature_sensor(sens))
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(TuyaFan), cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya), cv.Optional(CONF_OSCILLATION_DATAPOINT): cv.uint8_t, cv.Optional(CONF_SPEED_DATAPOINT): cv.uint8_t, cv.Optional(CONF_SWITCH_DATAPOINT): cv.uint8_t, cv.Optional(CONF_DIRECTION_DATAPOINT): cv.uint8_t, cv.Optional(CONF_SPEED_COUNT, default=3): cv.int_range(min=1, max=256), }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_SPEED_DATAPOINT, CONF_SWITCH_DATAPOINT), ) async def to_code(config): parent = await cg.get_variable(config[CONF_TUYA_ID]) var = cg.new_Pvariable(config[CONF_OUTPUT_ID], parent, config[CONF_SPEED_COUNT]) await cg.register_component(var, config) await fan.register_fan(var, config) if CONF_SPEED_DATAPOINT in config: cg.add(var.set_speed_id(config[CONF_SPEED_DATAPOINT])) if CONF_SWITCH_DATAPOINT in config: cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT]))
SDS011_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(SDS011Sensor), }) PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(SDS011Component), cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent), vol.Optional(CONF_RX_ONLY): cv.boolean, vol.Optional(CONF_PM_2_5): cv.nameable(SDS011_SENSOR_SCHEMA), vol.Optional(CONF_PM_10_0): cv.nameable(SDS011_SENSOR_SCHEMA), vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_minutes, }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_PM_2_5, CONF_PM_10_0), validate_sds011_rx_mode) def to_code(config): for uart_ in get_variable(config[CONF_UART_ID]): yield rhs = App.make_sds011(uart_) sds011 = Pvariable(config[CONF_ID], rhs) if CONF_UPDATE_INTERVAL in config: add(sds011.set_update_interval_min(config.get(CONF_UPDATE_INTERVAL))) if CONF_RX_ONLY in config: add(sds011.set_rx_mode_only(config[CONF_RX_ONLY]))
vol.Optional(CONF_GYRO_Z): cv.nameable( sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor), })), vol.Optional(CONF_TEMPERATURE): cv.nameable( sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(MPU6050TemperatureSensor), })), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS)) def to_code(config): rhs = App.make_mpu6050_sensor(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL)) mpu = Pvariable(config[CONF_ID], rhs) if CONF_ACCEL_X in config: conf = config[CONF_ACCEL_X] rhs = mpu.Pmake_accel_x_sensor(conf[CONF_NAME]) sensor.register_sensor(rhs, conf) if CONF_ACCEL_Y in config: conf = config[CONF_ACCEL_Y] rhs = mpu.Pmake_accel_y_sensor(conf[CONF_NAME]) sensor.register_sensor(rhs, conf) if CONF_ACCEL_Z in config:
vol.Required(CONF_TYPE): cv.one_of(*PMSX003_TYPES, upper=True), vol.Optional(CONF_PM_1_0): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_PM_2_5): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_PM_10_0): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_TEMPERATURE): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_HUMIDITY): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_FORMALDEHYDE): cv.nameable(PMSX003_SENSOR_SCHEMA), }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSORS_TO_TYPE)) def to_code(config): for uart_ in get_variable(config[CONF_UART_ID]): yield rhs = App.make_pmsx003(uart_, PMSX003_TYPES[config[CONF_TYPE]]) pms = Pvariable(config[CONF_ID], rhs) if CONF_PM_1_0 in config: conf = config[CONF_PM_1_0] sensor.register_sensor(pms.make_pm_1_0_sensor(conf[CONF_NAME]), conf) if CONF_PM_2_5 in config: conf = config[CONF_PM_2_5]
cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE): cv.temperature, cv.Optional(CONF_COOL_OUTPUT): cv.use_id(output.FloatOutput), cv.Optional(CONF_HEAT_OUTPUT): cv.use_id(output.FloatOutput), cv.Required(CONF_CONTROL_PARAMETERS): cv.Schema({ cv.Required(CONF_KP): cv.float_, cv.Optional(CONF_KI, default=0.0): cv.float_, cv.Optional(CONF_KD, default=0.0): cv.float_, cv.Optional(CONF_MIN_INTEGRAL, default=-1): cv.float_, cv.Optional(CONF_MAX_INTEGRAL, default=1): cv.float_, }), }), cv.has_at_least_one_key(CONF_COOL_OUTPUT, CONF_HEAT_OUTPUT), ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await climate.register_climate(var, config) sens = await cg.get_variable(config[CONF_SENSOR]) cg.add(var.set_sensor(sens)) if CONF_COOL_OUTPUT in config: out = await cg.get_variable(config[CONF_COOL_OUTPUT]) cg.add(var.set_cool_output(out)) if CONF_HEAT_OUTPUT in config:
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"), (cg.std_vector.template(cg.uint8), "bytes")], action, ) cg.add(trigger.set_direction(config[CONF_DIRECTION])) after = config[CONF_AFTER]
raise cv.Invalid("data must either be a string wrapped in quotes or a list of bytes") def validate_rx_pin(value): value = pins.input_pin(value) if CORE.is_esp8266 and value >= 16: raise cv.Invalid("Pins GPIO16 and GPIO17 cannot be used as RX pins on ESP8266.") return value CONFIG_SCHEMA = cv.All(cv.Schema({ cv.GenerateID(): cv.declare_id(UARTComponent), cv.Required(CONF_BAUD_RATE): cv.int_range(min=1, max=115200), cv.Optional(CONF_TX_PIN): pins.output_pin, cv.Optional(CONF_RX_PIN): validate_rx_pin, }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) cg.add(var.set_baud_rate(config[CONF_BAUD_RATE])) if CONF_TX_PIN in config: cg.add(var.set_tx_pin(config[CONF_TX_PIN])) if CONF_RX_PIN in config: cg.add(var.set_rx_pin(config[CONF_RX_PIN])) # A schema to use for all UART devices, all UART integrations must extend this!
yield effect @register_effect('strobe', StrobeLightEffect, "Strobe", { cv.Optional(CONF_COLORS, default=[ {CONF_STATE: True, CONF_DURATION: '0.5s'}, {CONF_STATE: False, CONF_DURATION: '0.5s'}, ]): cv.All(cv.ensure_list(cv.Schema({ cv.Optional(CONF_STATE, default=True): cv.boolean, cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage, cv.Optional(CONF_RED, default=1.0): cv.percentage, cv.Optional(CONF_GREEN, default=1.0): cv.percentage, cv.Optional(CONF_BLUE, default=1.0): cv.percentage, cv.Optional(CONF_WHITE, default=1.0): cv.percentage, cv.Required(CONF_DURATION): cv.positive_time_period_milliseconds, }), cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE, CONF_WHITE)), cv.Length(min=2)), }) def strobe_effect_to_code(config, effect_id): var = cg.new_Pvariable(effect_id, config[CONF_NAME]) colors = [] for color in config.get(CONF_COLORS, []): colors.append(cg.StructInitializer( StrobeLightEffectColor, ('color', LightColorValues(color[CONF_STATE], color[CONF_BRIGHTNESS], color[CONF_RED], color[CONF_GREEN], color[CONF_BLUE], color[CONF_WHITE])), ('duration', color[CONF_DURATION]), )) cg.add(var.set_colors(colors)) yield var
cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya), cv.Optional(CONF_SWITCH_DATAPOINT): cv.uint8_t, cv.Optional(CONF_TARGET_TEMPERATURE_DATAPOINT): cv.uint8_t, cv.Optional(CONF_CURRENT_TEMPERATURE_DATAPOINT): cv.uint8_t, cv.Optional(CONF_TEMPERATURE_MULTIPLIER): cv.positive_float, cv.Optional(CONF_CURRENT_TEMPERATURE_MULTIPLIER): cv.positive_float, cv.Optional(CONF_TARGET_TEMPERATURE_MULTIPLIER): cv.positive_float, }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_TARGET_TEMPERATURE_DATAPOINT, CONF_SWITCH_DATAPOINT), validate_temperature_multipliers, ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await climate.register_climate(var, config) paren = await cg.get_variable(config[CONF_TUYA_ID]) cg.add(var.set_tuya_parent(paren)) if CONF_SWITCH_DATAPOINT in config: cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT])) if CONF_TARGET_TEMPERATURE_DATAPOINT in config:
cv.Optional(CONF_COLOR_TEMPERATURE): cv.color_temperature, cv.Optional(CONF_COLD_WHITE, default=1.0): cv.percentage, cv.Optional(CONF_WARM_WHITE, default=1.0): cv.percentage, cv.Required(CONF_DURATION): cv.positive_time_period_milliseconds, }), cv.has_at_least_one_key( CONF_STATE, CONF_BRIGHTNESS, CONF_COLOR_MODE, CONF_COLOR_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE, CONF_WHITE, CONF_COLOR_TEMPERATURE, CONF_COLD_WHITE, CONF_WARM_WHITE, ), ), cv.Length(min=2), ), }, ) async def strobe_effect_to_code(config, effect_id): var = cg.new_Pvariable(effect_id, config[CONF_NAME]) colors = [] for color in config.get(CONF_COLORS, []):
from esphome.cpp_generator import Pvariable, add from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \ setup_component from esphome.cpp_types import App, Component, esphome_ns SPIComponent = esphome_ns.class_('SPIComponent', Component) SPIDevice = esphome_ns.class_('SPIDevice') MULTI_CONF = True CONFIG_SCHEMA = vol.All( vol.Schema({ cv.GenerateID(): cv.declare_variable_id(SPIComponent), vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema, vol.Optional(CONF_MISO_PIN): pins.gpio_input_pin_schema, vol.Optional(CONF_MOSI_PIN): pins.gpio_output_pin_schema, }), cv.has_at_least_one_key(CONF_MISO_PIN, CONF_MOSI_PIN)) def to_code(config): for clk in gpio_output_pin_expression(config[CONF_CLK_PIN]): yield rhs = App.init_spi(clk) spi = Pvariable(config[CONF_ID], rhs) if CONF_MISO_PIN in config: for miso in gpio_input_pin_expression(config[CONF_MISO_PIN]): yield add(spi.set_miso(miso)) if CONF_MOSI_PIN in config: for mosi in gpio_input_pin_expression(config[CONF_MOSI_PIN]): yield add(spi.set_mosi(mosi))
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) await binary_sensor.register_binary_sensor(var, config) await cg.register_component(var, config) if config.keys() >= {CONF_PAGE_ID, CONF_COMPONENT_ID}: cg.add(hub.register_touch_component(var)) cg.add(var.set_component_id(config[CONF_COMPONENT_ID])) cg.add(var.set_page_id(config[CONF_PAGE_ID]))
cv.string_strict, cv.Optional(CONF_USERNAME): cv.string_strict, cv.Optional(CONF_PASSWORD): cv.string_strict, cv.Optional(CONF_CERTIFICATE_AUTHORITY): wpa2_eap.validate_certificate, cv.Inclusive(CONF_CERTIFICATE, "certificate_and_key"): wpa2_eap.validate_certificate, # Only validate as file first because we need the password to load it # Actual validation happens in validate_eap. cv.Inclusive(CONF_KEY, "certificate_and_key"): cv.file_, }), wpa2_eap.validate_eap, cv.has_at_least_one_key(CONF_IDENTITY, CONF_CERTIFICATE), ) WIFI_NETWORK_BASE = cv.Schema({ cv.GenerateID(): cv.declare_id(WiFiAP), cv.Optional(CONF_SSID): cv.ssid, cv.Optional(CONF_PASSWORD): validate_password, cv.Optional(CONF_CHANNEL): validate_channel, cv.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA, })
vol.Optional(CONF_POWER): cv.nameable( sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(HLW8012PowerSensor), })), vol.Optional(CONF_CURRENT_RESISTOR): cv.resistance, vol.Optional(CONF_VOLTAGE_DIVIDER): cv.positive_float, vol.Optional(CONF_CHANGE_MODE_EVERY): vol.All(cv.uint32_t, vol.Range(min=1)), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT, CONF_POWER)) def to_code(config): for sel in gpio_output_pin_expression(config[CONF_SEL_PIN]): yield rhs = App.make_hlw8012(sel, config[CONF_CF_PIN], config[CONF_CF1_PIN], config.get(CONF_UPDATE_INTERVAL)) hlw = Pvariable(config[CONF_ID], rhs) if CONF_VOLTAGE in config: conf = config[CONF_VOLTAGE] sensor.register_sensor(hlw.make_voltage_sensor(conf[CONF_NAME]), conf) if CONF_CURRENT in config: conf = config[CONF_CURRENT]
cv.GenerateID(): cv.declare_id(Number), cv.Optional(CONF_ON_VALUE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(NumberStateTrigger), }), cv.Optional(CONF_ON_VALUE_RANGE): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ValueRangeTrigger), cv.Optional(CONF_ABOVE): cv.templatable(cv.float_), cv.Optional(CONF_BELOW): cv.templatable(cv.float_), }, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW), ), cv.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string_strict, cv.Optional(CONF_MODE, default="AUTO"): cv.enum(NUMBER_MODES, upper=True), }) async def setup_number_core_(var, config, *, min_value: float, max_value: float, step: Optional[float]): await setup_entity(var, config) cg.add(var.traits.set_min_value(min_value)) cg.add(var.traits.set_max_value(max_value)) if step is not None:
PMSX003_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(PMSX003Sensor), }) PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(PMSX003Component), cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent), vol.Required(CONF_TYPE): cv.one_of(*PMSX003_TYPES, upper=True), vol.Optional(CONF_PM_1_0): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_PM_2_5): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_PM_10_0): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_TEMPERATURE): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_HUMIDITY): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_FORMALDEHYDE): cv.nameable(PMSX003_SENSOR_SCHEMA), }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSORS_TO_TYPE)) def to_code(config): for uart_ in get_variable(config[CONF_UART_ID]): yield rhs = App.make_pmsx003(uart_, PMSX003_TYPES[config[CONF_TYPE]]) pms = Pvariable(config[CONF_ID], rhs) if CONF_PM_1_0 in config: conf = config[CONF_PM_1_0] sensor.register_sensor(pms.make_pm_1_0_sensor(conf[CONF_NAME]), conf) if CONF_PM_2_5 in config: conf = config[CONF_PM_2_5]