cv.GenerateID(CONF_ID): cv.declare_id(HBridgeFan),
cv.Required(CONF_PIN_A): cv.use_id(output.FloatOutput),
cv.Required(CONF_PIN_B): cv.use_id(output.FloatOutput),
cv.Optional(CONF_DECAY_MODE, default="SLOW"): cv.enum(
DECAY_MODE_OPTIONS, upper=True
),
cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
cv.Optional(CONF_ENABLE_PIN): cv.use_id(output.FloatOutput),
}
).extend(cv.COMPONENT_SCHEMA)
@automation.register_action(
"fan.hbridge.brake",
BrakeAction,
maybe_simple_id({cv.Required(CONF_ID): cv.use_id(HBridgeFan)}),
)
async def fan_hbridge_brake_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
async def to_code(config):
var = cg.new_Pvariable(
config[CONF_ID],
config[CONF_SPEED_COUNT],
config[CONF_DECAY_MODE],
)
await fan.register_fan(var, config)
pin_a_ = await cg.get_variable(config[CONF_PIN_A])
cg.add(var.set_pin_a(pin_a_))
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_binary_sensor(var))
yield setup_binary_sensor_core_(var, config)
@coroutine
def new_binary_sensor(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
yield register_binary_sensor(var, config)
yield var
BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(BinarySensor),
cv.Optional(CONF_FOR): cv.invalid("This option has been removed in 1.13, please use the "
"'for' condition instead."),
})
@automation.register_condition('binary_sensor.is_on', BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(condition_id, template_arg, paren, True)
@automation.register_condition('binary_sensor.is_off', BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
cg.add(obj.set_power_supply(power_supply_))
if CONF_MAX_POWER in config:
cg.add(obj.set_max_power(config[CONF_MAX_POWER]))
if CONF_MIN_POWER in config:
cg.add(obj.set_min_power(config[CONF_MIN_POWER]))
@coroutine
def register_output(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
yield setup_output_platform_(var, config)
BINARY_OUTPUT_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(BinaryOutput),
})
@automation.register_action('output.turn_on', TurnOnAction,
BINARY_OUTPUT_ACTION_SCHEMA)
def output_turn_on_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('output.turn_off', TurnOffAction,
BINARY_OUTPUT_ACTION_SCHEMA)
def output_turn_off_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_fan(var))
yield cg.register_component(var, config)
yield setup_fan_core_(var, config)
@coroutine
def create_fan_state(config):
var = cg.new_Pvariable(config[CONF_ID])
yield register_fan(var, config)
yield var
FAN_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(FanState),
})
@automation.register_action('fan.toggle', ToggleAction, FAN_ACTION_SCHEMA)
def fan_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('fan.turn_off', TurnOffAction, FAN_ACTION_SCHEMA)
def fan_turn_off_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
cg.add(var.set_run_duration(config[CONF_RUN_DURATION]))
if CONF_ESP32_EXT1_WAKEUP in config:
conf = config[CONF_ESP32_EXT1_WAKEUP]
mask = 0
for pin in conf[CONF_PINS]:
mask |= 1 << pin[CONF_NUMBER]
struct = cg.StructInitializer(Ext1Wakeup, ('mask', mask),
('wakeup_mode', conf[CONF_MODE]))
cg.add(var.set_ext1_wakeup(struct))
cg.add_define('USE_DEEP_SLEEP')
DEEP_SLEEP_ACTION_SCHEMA = maybe_simple_id({
cv.GenerateID():
cv.use_id(DeepSleepComponent),
})
@automation.register_action('deep_sleep.enter', EnterDeepSleepAction,
DEEP_SLEEP_ACTION_SCHEMA)
def deep_sleep_enter_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('deep_sleep.prevent', PreventDeepSleepAction,
DEEP_SLEEP_ACTION_SCHEMA)
def deep_sleep_prevent_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
cg.add(var.set_gains(config[CONF_CURRENT_GAIN], config[CONF_VOLTAGE_GAIN]))
cg.add(var.set_hpf_enable(config[CONF_CURRENT_HPF], config[CONF_VOLTAGE_HPF]))
cg.add(var.set_pulse_energy_wh(config[CONF_PULSE_ENERGY]))
if CONF_VOLTAGE in config:
conf = config[CONF_VOLTAGE]
sens = await sensor.new_sensor(conf)
cg.add(var.set_voltage_sensor(sens))
if CONF_CURRENT in config:
conf = config[CONF_CURRENT]
sens = await sensor.new_sensor(conf)
cg.add(var.set_current_sensor(sens))
if CONF_POWER in config:
conf = config[CONF_POWER]
sens = await sensor.new_sensor(conf)
cg.add(var.set_power_sensor(sens))
@automation.register_action(
"cs5460a.restart",
CS5460ARestartAction,
maybe_simple_id(
{
cv.Required(CONF_ID): cv.use_id(CS5460AComponent),
}
),
)
async def restart_action_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_fan(var))
yield cg.register_component(var, config)
yield setup_fan_core_(var, config)
@coroutine
def create_fan_state(config):
var = cg.new_Pvariable(config[CONF_ID])
yield register_fan(var, config)
yield var
FAN_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(FanState),
})
@automation.register_action('fan.toggle', ToggleAction, FAN_ACTION_SCHEMA)
def fan_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('fan.turn_off', TurnOffAction, FAN_ACTION_SCHEMA)
def fan_turn_off_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
if CONF_DIR_PIN in config:
dir_pin = await cg.gpio_pin_expression(config[CONF_DIR_PIN])
cg.add(var.set_dir_pin(dir_pin))
cg.add(var.set_driver_address(config[CONF_DRIVER_ADDRESS]))
cg.add(var.set_stall_threshold(config[CONF_STALL_THRESHOLD]))
cg.add(var.set_microsteps(config[CONF_MICROSTEPS]))
cg.add(var.set_rms_current(config[CONF_RMS_CURRENT]))
if CONF_COVER in config:
config_cover = config[CONF_COVER]
cover_var = cg.new_Pvariable(config_cover[CONF_ID])
await cg.register_component(cover_var, config_cover)
await cover.register_cover(cover_var, config_cover)
cg.add(cover_var.set_stepper(var))
@automation.register_action(
"stepper.calibrate",
CalibrateAction,
automation.maybe_simple_id(
{
cv.Required(CONF_ID): cv.use_id(TMC2209),
}
) ,
)
async def stepper_calibrate_to_code(config, action_id, template_arg, args):
parent = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, parent)
return var
page = await cg.get_variable(conf[CONF_TO])
cg.add(trigger.set_to(page))
await automation.build_automation(trigger, [(DisplayPagePtr, "from"),
(DisplayPagePtr, "to")],
conf)
async def register_display(var, config):
await setup_display_core_(var, config)
@automation.register_action(
"display.page.show",
DisplayPageShowAction,
maybe_simple_id({
cv.Required(CONF_ID):
cv.templatable(cv.use_id(DisplayPage)),
}),
)
async def display_page_show_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
if isinstance(config[CONF_ID], core.Lambda):
template_ = await cg.templatable(config[CONF_ID], args, DisplayPagePtr)
cg.add(var.set_page(template_))
else:
paren = await cg.get_variable(config[CONF_ID])
cg.add(var.set_page(paren))
return var
@automation.register_action(
"display.page.show_next",
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
template_ = await cg.templatable(config[CONF_START], args, cg.uint8)
cg.add(var.set_start(template_))
template_ = await cg.templatable(config[CONF_END], args, cg.uint8)
cg.add(var.set_end(template_))
cg.add(var.set_memory(get_memory_address(config[CONF_MEMORY])))
for conf in config.get(CONF_ON_DUMP_FINISH, []):
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
cg.add(var.register_finish_trigger(trigger))
await automation.build_automation(trigger, [(cg.std_string, "data")],
conf)
return var
@automation.register_condition("extraflame.is_dumping",
ExtraflameIsDumpingCondition,
maybe_simple_id({
cv.GenerateID():
cv.use_id(ExtraflameHub),
}))
async def extraflame_is_dumping_to_code(config, condition_id, template_arg,
args):
cg.add_define("USE_EXTRAFLAME_DUMP")
var = cg.new_Pvariable(condition_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
return var
CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(IntegrationSensor),
cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
cv.Required(CONF_TIME_UNIT): cv.enum(INTEGRATION_TIMES, lower=True),
cv.Optional(CONF_INTEGRATION_METHOD, default='trapezoid'):
cv.enum(INTEGRATION_METHODS, lower=True),
cv.Optional(CONF_RESTORE, default=False): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
sens = yield cg.get_variable(config[CONF_SENSOR])
cg.add(var.set_sensor(sens))
cg.add(var.set_time(config[CONF_TIME_ID]))
cg.add(var.set_method(config[CONF_INTEGRATION_METHOD]))
cg.add(var.set_restore(config[CONF_RESTORE]))
@automation.register_action('sensor.integration.reset', ResetAction, automation.maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
}))
def sensor_integration_reset_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
for key, funcName in SENSOR_MAP.items():
if key in config:
sens = await sensor.new_sensor(config[key])
cg.add(getattr(var, funcName)(sens))
if CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE in config:
sens = await cg.get_variable(config[CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE])
cg.add(var.set_ambient_pressure_source(sens))
cg.add(var.set_measurement_mode(config[CONF_MEASUREMENT_MODE]))
SCD4X_ACTION_SCHEMA = maybe_simple_id(
{
cv.GenerateID(): cv.use_id(SCD4XComponent),
cv.Required(CONF_VALUE): cv.templatable(cv.positive_int),
}
)
@automation.register_action(
"scd4x.perform_forced_calibration",
PerformForcedCalibrationAction,
SCD4X_ACTION_SCHEMA,
)
async def scd4x_frc_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
template_ = await cg.templatable(config[CONF_VALUE], args, cg.uint16)
cg.add(var.set_value(template_))
return var
if CONF_MQTT_ID in config:
mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
yield mqtt.register_mqtt_component(mqtt_, config)
@coroutine
def register_switch(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_switch(var))
yield setup_switch_core_(var, config)
SWITCH_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(Switch),
})
@automation.register_action('switch.toggle', ToggleAction, SWITCH_ACTION_SCHEMA)
@automation.register_action('switch.turn_off', TurnOffAction, SWITCH_ACTION_SCHEMA)
@automation.register_action('switch.turn_on', TurnOnAction, SWITCH_ACTION_SCHEMA)
def switch_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_condition('switch.is_on', SwitchCondition, SWITCH_ACTION_SCHEMA)
def switch_is_on_to_code(config, condition_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(condition_id, template_arg, paren, True)
),
cv.Optional(CONF_ON_PLAY): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PlayTrigger),
}
),
cv.Optional(CONF_ON_PAUSE): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
}
),
}
)
MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id({cv.GenerateID(): cv.use_id(MediaPlayer)})
@automation.register_action(
"media_player.play_media",
PlayMediaAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(MediaPlayer),
cv.Required(CONF_MEDIA_URL): cv.templatable(cv.url),
},
key=CONF_MEDIA_URL,
),
)
async def media_player_play_media_action(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
clk_pin = await cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk_pin))
dio_pin = await cg.gpio_pin_expression(config[CONF_DIO_PIN])
cg.add(var.set_dio_pin(dio_pin))
# https://platformio.org/lib/show/6865/TM1651
cg.add_library("freekode/TM1651", "1.0.1")
BINARY_OUTPUT_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(TM1651Display),
})
@automation.register_action("tm1651.turn_on", TurnOnAction,
BINARY_OUTPUT_ACTION_SCHEMA)
async def output_turn_on_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
return var
@automation.register_action("tm1651.turn_off", TurnOffAction,
BINARY_OUTPUT_ACTION_SCHEMA)
async def output_turn_off_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
LightState,
LightControlAction,
AddressableLightState,
AddressableSet,
LightIsOnCondition,
LightIsOffCondition,
)
@automation.register_action(
"light.toggle",
ToggleAction,
automation.maybe_simple_id(
{
cv.Required(CONF_ID): cv.use_id(LightState),
cv.Optional(CONF_TRANSITION_LENGTH): cv.templatable(
cv.positive_time_period_milliseconds
),
}
),
)
def light_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_TRANSITION_LENGTH in config:
template_ = yield cg.templatable(
config[CONF_TRANSITION_LENGTH], args, cg.uint32
)
cg.add(var.set_transition_length(template_))
yield var
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_fan(var))
yield cg.register_component(var, config)
yield setup_fan_core_(var, config)
@coroutine
def create_fan_state(config):
var = cg.new_Pvariable(config[CONF_ID])
yield register_fan(var, config)
yield var
FAN_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(FanState),
})
@automation.register_action("fan.toggle", ToggleAction, FAN_ACTION_SCHEMA)
def fan_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action("fan.turn_off", TurnOffAction, FAN_ACTION_SCHEMA)
def fan_turn_off_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action(
"servo.write",
ServoWriteAction,
cv.Schema({
cv.Required(CONF_ID):
cv.use_id(Servo),
cv.Required(CONF_LEVEL):
cv.templatable(cv.possibly_negative_percentage),
}),
)
def servo_write_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
template_ = yield cg.templatable(config[CONF_LEVEL], args, float)
cg.add(var.set_value(template_))
yield var
@automation.register_action(
"servo.detach",
ServoDetachAction,
maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(Servo),
}),
)
def servo_detach_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
cg.add(var.set_kd(params[CONF_KD]))
if CONF_MIN_INTEGRAL in params:
cg.add(var.set_min_integral(params[CONF_MIN_INTEGRAL]))
if CONF_MAX_INTEGRAL in params:
cg.add(var.set_max_integral(params[CONF_MAX_INTEGRAL]))
cg.add(
var.set_default_target_temperature(
config[CONF_DEFAULT_TARGET_TEMPERATURE]))
@automation.register_action(
"climate.pid.reset_integral_term",
PIDResetIntegralTermAction,
automation.maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(PIDClimate),
}),
)
async def pid_reset_integral_term(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action(
"climate.pid.autotune",
PIDAutotuneAction,
automation.maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(PIDClimate),
cv.Optional(CONF_NOISEBAND, default=0.25):
cv.float_,
cv.Optional(CONF_RESTORE, default=False):
cv.boolean,
}).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await sensor.register_sensor(var, config)
sens = await cg.get_variable(config[CONF_SENSOR])
cg.add(var.set_sensor(sens))
cg.add(var.set_time(config[CONF_TIME_UNIT]))
cg.add(var.set_method(config[CONF_INTEGRATION_METHOD]))
cg.add(var.set_restore(config[CONF_RESTORE]))
@automation.register_action(
"sensor.integration.reset",
ResetAction,
automation.maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(IntegrationSensor),
}),
)
async def sensor_integration_reset_to_code(config, action_id, template_arg,
args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
mask = 0
for pin in conf[CONF_PINS]:
mask |= 1 << pin[CONF_NUMBER]
struct = cg.StructInitializer(Ext1Wakeup, ("mask", mask),
("wakeup_mode", conf[CONF_MODE]))
cg.add(var.set_ext1_wakeup(struct))
if CONF_TOUCH_WAKEUP in config:
cg.add(var.set_touch_wakeup(config[CONF_TOUCH_WAKEUP]))
cg.add_define("USE_DEEP_SLEEP")
DEEP_SLEEP_ENTER_SCHEMA = automation.maybe_simple_id({
cv.GenerateID():
cv.use_id(DeepSleepComponent),
cv.Optional(CONF_SLEEP_DURATION):
cv.templatable(cv.positive_time_period_milliseconds),
})
DEEP_SLEEP_PREVENT_SCHEMA = automation.maybe_simple_id({
cv.GenerateID():
cv.use_id(DeepSleepComponent),
})
@automation.register_action("deep_sleep.enter", EnterDeepSleepAction,
DEEP_SLEEP_ENTER_SCHEMA)
async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_SLEEP_DURATION in config:
config[CONF_TILT_STATE_TOPIC]))
if CONF_TILT_COMMAND_TOPIC in config:
cg.add(
mqtt_.set_custom_tilt_command_topic(
config[CONF_TILT_COMMAND_TOPIC]))
async def register_cover(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_cover(var))
await setup_cover_core_(var, config)
COVER_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(Cover),
})
@automation.register_action("cover.open", OpenAction, COVER_ACTION_SCHEMA)
async def cover_open_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action("cover.close", CloseAction, COVER_ACTION_SCHEMA)
async def cover_close_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
),
}).extend(cv.polling_component_schema("60s")).extend(uart.UART_DEVICE_SCHEMA))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await uart.register_uart_device(var, config)
if CONF_CO2 in config:
sens = await sensor.new_sensor(config[CONF_CO2])
cg.add(var.set_co2_sensor(sens))
CALIBRATION_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(SenseAirComponent),
})
@automation.register_action(
"senseair.background_calibration",
SenseAirBackgroundCalibrationAction,
CALIBRATION_ACTION_SCHEMA,
)
@automation.register_action(
"senseair.background_calibration_result",
SenseAirBackgroundCalibrationResultAction,
CALIBRATION_ACTION_SCHEMA,
)
@automation.register_action("senseair.abc_enable", SenseAirABCEnableAction,
CALIBRATION_ACTION_SCHEMA)
add(
mqtt_.set_custom_speed_command_topic(
config[CONF_SPEED_COMMAND_TOPIC]))
setup_mqtt_component(mqtt_, config)
def setup_fan(fan_obj, config):
fan_var = Pvariable(config[CONF_ID], fan_obj, has_side_effects=False)
CORE.add_job(setup_fan_core_, fan_var, config)
BUILD_FLAGS = '-DUSE_FAN'
CONF_FAN_TOGGLE = 'fan.toggle'
FAN_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
vol.Required(CONF_ID):
cv.use_variable_id(FanState),
})
@ACTION_REGISTRY.register(CONF_FAN_TOGGLE, FAN_TOGGLE_ACTION_SCHEMA)
def fan_toggle_to_code(config, action_id, template_arg, args):
for var in get_variable(config[CONF_ID]):
yield None
rhs = var.make_toggle_action(template_arg)
type = ToggleAction.template(template_arg)
yield Pvariable(action_id, rhs, type=type)
CONF_FAN_TURN_OFF = 'fan.turn_off'
FAN_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
vol.Required(CONF_ID):
WriteAction,
cv.Schema({
cv.GenerateID(): cv.use_id(DS1307Component),
}),
)
async def ds1307_write_time_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
return var
@automation.register_action(
"ds1307.read_time",
ReadAction,
automation.maybe_simple_id({
cv.GenerateID(): cv.use_id(DS1307Component),
}),
)
async def ds1307_read_time_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
return var
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)
await time.register_time(var, config)
async def register_button(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_button(var))
await setup_button_core_(var, config)
async def new_button(config):
var = cg.new_Pvariable(config[CONF_ID])
await register_button(var, config)
return var
BUTTON_PRESS_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(Button),
})
@automation.register_action("button.press", PressAction, BUTTON_PRESS_SCHEMA)
async def button_press_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
@coroutine_with_priority(100.0)
async def to_code(config):
cg.add_global(button_ns.using)
cg.add_define("USE_BUTTON")
OPERATION_BASE_SCHEMA.extend(
{
cv.Required(CONF_OPERATION): cv.templatable(
cv.enum(SELECT_OPERATION_OPTIONS, upper=True)
),
cv.Optional(CONF_CYCLE, default=True): cv.templatable(cv.boolean),
}
),
)
@automation.register_action(
"select.next",
SelectOperationAction,
automation.maybe_simple_id(
OPERATION_BASE_SCHEMA.extend(
{
cv.Optional(CONF_MODE, default="NEXT"): cv.one_of("NEXT", upper=True),
cv.Optional(CONF_CYCLE, default=True): cv.boolean,
}
)
),
)
@automation.register_action(
"select.previous",
SelectOperationAction,
automation.maybe_simple_id(
OPERATION_BASE_SCHEMA.extend(
{
cv.Optional(CONF_MODE, default="PREVIOUS"): cv.one_of(
"PREVIOUS", upper=True
),
cv.Optional(CONF_CYCLE, default=True): cv.boolean,
}
async def register_binary_sensor(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_binary_sensor(var))
await setup_binary_sensor_core_(var, config)
async def new_binary_sensor(config):
var = cg.new_Pvariable(config[CONF_ID])
await register_binary_sensor(var, config)
return var
BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(BinarySensor),
})
@automation.register_condition("binary_sensor.is_on", BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
async def binary_sensor_is_on_to_code(config, condition_id, template_arg,
args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(condition_id, template_arg, paren, True)
@automation.register_condition("binary_sensor.is_off", BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
async def binary_sensor_is_off_to_code(config, condition_id, template_arg,
args):
cg.add(trigger.set_max_runs(conf[CONF_MAX_RUNS]))
if conf[CONF_MODE] == CONF_QUEUED:
await cg.register_component(trigger, conf)
triggers.append((trigger, conf))
for trigger, conf in triggers:
await automation.build_automation(trigger, [], conf)
@automation.register_action(
"script.execute",
ScriptExecuteAction,
maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(Script),
}),
)
async def script_execute_action_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action(
"script.stop",
ScriptStopAction,
maybe_simple_id({cv.Required(CONF_ID): cv.use_id(Script)}),
)
async def script_stop_action_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
'binary_sensor',
config,
include_state=True,
include_command=False)
if ret is None:
return None
if CONF_DEVICE_CLASS in config:
ret['device_class'] = config[CONF_DEVICE_CLASS]
return ret
BUILD_FLAGS = '-DUSE_BINARY_SENSOR'
CONF_BINARY_SENSOR_IS_ON = 'binary_sensor.is_on'
BINARY_SENSOR_IS_ON_CONDITION_SCHEMA = maybe_simple_id({
vol.Required(CONF_ID):
cv.use_variable_id(BinarySensor),
})
@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_ON,
BINARY_SENSOR_IS_ON_CONDITION_SCHEMA)
def binary_sensor_is_on_to_code(config, condition_id, arg_type, template_arg):
for var in get_variable(config[CONF_ID]):
yield None
rhs = var.make_binary_sensor_is_on_condition(template_arg)
type = BinarySensorCondition.template(arg_type)
yield Pvariable(condition_id, rhs, type=type)
CONF_BINARY_SENSOR_IS_OFF = 'binary_sensor.is_off'
BINARY_SENSOR_IS_OFF_CONDITION_SCHEMA = maybe_simple_id({
