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]
