@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)
await cg.register_parented(var, config[CONF_ID])
return var
@automation.register_action(
"tm1651.set_level_percent",
SetLevelPercentAction,
cv.maybe_simple_value(
{
cv.GenerateID():
cv.use_id(TM1651Display),
cv.Required(CONF_LEVEL_PERCENT):
cv.templatable(validate_level_percent),
},
key=CONF_LEVEL_PERCENT,
),
)
async def tm1651_set_level_percent_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_LEVEL_PERCENT], args,
cg.uint8)
cg.add(var.set_level_percent(template_))
return var
}
),
)
def dfplayer_previous_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_parented(var, config[CONF_ID])
yield var
@automation.register_action(
"dfplayer.play",
PlayFileAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(DFPlayer),
cv.Required(CONF_FILE): cv.templatable(cv.int_),
cv.Optional(CONF_LOOP): cv.templatable(cv.boolean),
},
key=CONF_FILE,
),
)
def dfplayer_play_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_parented(var, config[CONF_ID])
template_ = yield cg.templatable(config[CONF_FILE], args, float)
cg.add(var.set_file(template_))
if CONF_LOOP in config:
template_ = yield cg.templatable(config[CONF_LOOP], args, float)
cg.add(var.set_loop(template_))
yield var
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
out = yield cg.get_variable(config[CONF_OUTPUT])
cg.add(var.set_output(out))
for conf in config.get(CONF_ON_FINISHED_PLAYBACK, []):
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
yield automation.build_automation(trigger, [], conf)
@automation.register_action('rtttl.play', PlayAction, cv.maybe_simple_value({
cv.GenerateID(CONF_ID): cv.use_id(Rtttl),
cv.Required(CONF_RTTTL): cv.templatable(cv.string)
}, key=CONF_RTTTL))
def rtttl_play_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_RTTTL], args, cg.std_string)
cg.add(var.set_value(template_))
yield var
@automation.register_action('rtttl.stop', StopAction, cv.Schema({
cv.GenerateID(): cv.use_id(Rtttl),
}))
def rtttl_stop_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_parented(var, config[CONF_ID])
cv.templatable(cv.use_id(DisplayBuffer)),
}),
)
async def display_page_show_previous_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_condition(
"display.is_displaying_page",
DisplayIsDisplayingPageCondition,
cv.maybe_simple_value(
{
cv.GenerateID(CONF_ID): cv.use_id(DisplayBuffer),
cv.Required(CONF_PAGE_ID): cv.use_id(DisplayPage),
},
key=CONF_PAGE_ID,
),
)
async def display_is_displaying_page_to_code(config, condition_id,
template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
page = await cg.get_variable(config[CONF_PAGE_ID])
var = cg.new_Pvariable(condition_id, template_arg, paren)
cg.add(var.set_page(page))
return var
@coroutine_with_priority(100.0)
@coroutine
def templated_payload_getter_to_code(type, config, payload_id, template_arg,
args):
template_arg = cg.TemplateArguments(type, *[arg[0] for arg in args])
var = cg.new_Pvariable(payload_id, template_arg, args)
template = yield cg.templatable(config[ehc.CONF_VALUE], args, type)
cg.add(var.set_value(template))
yield var
@register_payload_getter(c.PAYLOAD_BOOL, t.TemplatePayloadGetter,
cv.maybe_simple_value(cv.Schema({
cv.GenerateID():
cv.declare_id(t.TemplatePayloadGetter),
cv.Required(ehc.CONF_VALUE):
cv.templatable(cv.boolean),
}),
key=ehc.CONF_VALUE))
@coroutine
def bool_payload_getter_to_code(config, payload_id, template_arg, args):
yield templated_payload_getter_to_code(cg.bool_, config, payload_id,
template_arg, args)
@register_payload_getter(c.PAYLOAD_FLOAT, t.TemplatePayloadGetter,
cv.maybe_simple_value(cv.Schema({
cv.GenerateID():
cv.declare_id(t.TemplatePayloadGetter),
cv.Required(ehc.CONF_VALUE):
cv.templatable(cv.float_),
out = await cg.get_variable(config[CONF_OUTPUT])
cg.add(var.set_output(out))
for conf in config.get(CONF_ON_FINISHED_PLAYBACK, []):
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
await automation.build_automation(trigger, [], conf)
@automation.register_action(
"rtttl.play",
PlayAction,
cv.maybe_simple_value(
{
cv.GenerateID(CONF_ID): cv.use_id(Rtttl),
cv.Required(CONF_RTTTL): cv.templatable(cv.string),
},
key=CONF_RTTTL,
),
)
async def rtttl_play_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)
template_ = await cg.templatable(config[CONF_RTTTL], args, cg.std_string)
cg.add(var.set_value(template_))
return var
@automation.register_action(
"rtttl.stop",
StopAction,
}
),
}
)
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)
await cg.register_parented(var, config[CONF_ID])
media_url = await cg.templatable(config[CONF_MEDIA_URL], args, cg.std_string)
cg.add(var.set_media_url(media_url))
return var
@automation.register_action("media_player.play", PlayAction, MEDIA_PLAYER_ACTION_SCHEMA)
@automation.register_action(
"media_player.toggle", ToggleAction, MEDIA_PLAYER_ACTION_SCHEMA
yield cg.register_component(var, config)
clk_pin = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk_pin))
dio_pin = yield 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('6865', '1.0.0')
@automation.register_action(
'tm1651.set_level', SetLevelAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(TM1651Display),
cv.Required(CONF_LEVEL): cv.templatable(validate_level),
},
key=CONF_LEVEL))
def tm1651_set_level_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_parented(var, config[CONF_ID])
template_ = yield cg.templatable(config[CONF_LEVEL], args, cg.uint8)
cg.add(var.set_level(template_))
yield var
@automation.register_action(
'tm1651.set_brightness', SetBrightnessAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(TM1651Display),
}
),
)
async def repeat_action_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
count_template = await cg.templatable(config[CONF_COUNT], args, cg.uint32)
cg.add(var.set_count(count_template))
actions = await build_action_list(config[CONF_THEN], template_arg, args)
cg.add(var.add_then(actions))
return var
_validate_wait_until = cv.maybe_simple_value(
{
cv.Required(CONF_CONDITION): validate_potentially_and_condition,
cv.Optional(CONF_TIMEOUT): cv.templatable(cv.positive_time_period_milliseconds),
},
key=CONF_CONDITION,
)
@register_action("wait_until", WaitUntilAction, _validate_wait_until)
async def wait_until_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_TIMEOUT in config:
template_ = await cg.templatable(config[CONF_TIMEOUT], args, cg.uint32)
cg.add(var.set_timeout_value(template_))
await cg.register_component(var, {})
return var
await automation.build_automation(trigger, [(cg.uint16, "finger_id")],
conf)
for conf in config.get(CONF_ON_ENROLLMENT_FAILED, []):
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
await automation.build_automation(trigger, [(cg.uint16, "finger_id")],
conf)
@automation.register_action(
"fingerprint_grow.enroll",
EnrollmentAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
cv.Required(CONF_FINGER_ID): cv.templatable(cv.uint16_t),
cv.Optional(CONF_NUM_SCANS): cv.templatable(cv.uint8_t),
},
key=CONF_FINGER_ID,
),
)
async def fingerprint_grow_enroll_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_FINGER_ID], args, cg.uint16)
cg.add(var.set_finger_id(template_))
if CONF_NUM_SCANS in config:
template_ = await cg.templatable(config[CONF_NUM_SCANS], args,
cg.uint8)
cg.add(var.set_num_scans(template_))
if len(matches) != len(value[CONF_ARGS]):
raise cv.Invalid(
f"Found {len(matches)} printf-patterns ({', '.join(matches)}), but {len(value[CONF_ARGS])} args were given!"
)
return value
CONF_LOGGER_LOG = "logger.log"
LOGGER_LOG_ACTION_SCHEMA = cv.All(
cv.maybe_simple_value(
{
cv.Required(CONF_FORMAT):
cv.string,
cv.Optional(CONF_ARGS, default=list):
cv.ensure_list(cv.lambda_),
cv.Optional(CONF_LEVEL, default="DEBUG"):
cv.one_of(*LOG_LEVEL_TO_ESP_LOG, upper=True),
cv.Optional(CONF_TAG, default="main"):
cv.string,
},
validate_printf,
key=CONF_FORMAT,
))
@automation.register_action(CONF_LOGGER_LOG, LambdaAction,
LOGGER_LOG_ACTION_SCHEMA)
async def logger_log_action_to_code(config, action_id, template_arg, args):
esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
args_ = [cg.RawExpression(str(x)) for x in config[CONF_ARGS]]
text = str(
raise cv.Invalid(
f"Either {CONF_VALVE_SWITCH_ID} or {CONF_VALVE_OFF_SWITCH_ID} and {CONF_VALVE_ON_SWITCH_ID} must be specified in valve configuration"
)
return config
SPRINKLER_ACTION_SCHEMA = maybe_simple_id(
{
cv.Required(CONF_ID): cv.use_id(Sprinkler),
}
)
SPRINKLER_ACTION_REPEAT_SCHEMA = cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(Sprinkler),
cv.Required(CONF_REPEAT): cv.templatable(cv.positive_int),
},
key=CONF_REPEAT,
)
SPRINKLER_ACTION_SINGLE_VALVE_SCHEMA = cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(Sprinkler),
cv.Required(CONF_VALVE_NUMBER): cv.templatable(cv.positive_int),
},
key=CONF_VALVE_NUMBER,
)
SPRINKLER_ACTION_SET_MULTIPLIER_SCHEMA = cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(Sprinkler),
if conf is None:
return
data = conf[CONF_DATA]
if CONF_ACK in conf:
ack = conf[CONF_ACK]
return data, ack
else:
return data
@automation.register_action(
'rs485.write', RS485WriteAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(RS485Component),
cv.Required(CONF_DATA): cv.templatable(validate_hex_data),
cv.Optional(CONF_ACK, default=[]): validate_hex_data
},
key=CONF_DATA))
async def rs485_write_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
data = config[CONF_DATA]
if cg.is_template(data):
templ = await cg.templatable(data, args, cmd_hex_t)
cg.add(var.set_data_template(templ))
else:
cmd = await command_hex_expression(config)
cg.add(var.set_data_static(cmd))
return var
cv.GenerateID(CONF_UART_ID): cv.use_id(UARTComponent),
})
@coroutine
def register_uart_device(var, config):
"""Register a UART device, setting up all the internal values.
This is a coroutine, you need to await it with a 'yield' expression!
"""
parent = yield cg.get_variable(config[CONF_UART_ID])
cg.add(var.set_uart_parent(parent))
@automation.register_action('uart.write', UARTWriteAction, cv.maybe_simple_value({
cv.GenerateID(): cv.use_id(UARTComponent),
cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
}, key=CONF_DATA))
def uart_write_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_parented(var, config[CONF_ID])
data = config[CONF_DATA]
if isinstance(data, binary_type):
data = [char_to_byte(x) for x in data]
if cg.is_template(data):
templ = yield cg.templatable(data, args, cg.std_vector.template(cg.uint8))
cg.add(var.set_data_template(templ))
else:
cg.add(var.set_data_static(data))
yield var
async def register_uart_device(var, config):
"""Register a UART device, setting up all the internal values.
This is a coroutine, you need to await it with a 'yield' expression!
"""
parent = await cg.get_variable(config[CONF_UART_ID])
cg.add(var.set_uart_parent(parent))
@automation.register_action(
"uart.write",
UARTWriteAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(UARTComponent),
cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
},
key=CONF_DATA,
),
)
async def uart_write_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_ID])
data = config[CONF_DATA]
if isinstance(data, bytes):
data = list(data)
if cg.is_template(data):
templ = await cg.templatable(data, args,
cg.std_vector.template(cg.uint8))
cg.add(var.set_data_template(templ))
async def register_canbus(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.new_Pvariable(config[CONF_ID], var)
await setup_canbus_core_(var, config)
# Actions
@automation.register_action(
"canbus.send",
canbus_ns.class_("CanbusSendAction", automation.Action),
cv.maybe_simple_value(
{
cv.GenerateID(CONF_CANBUS_ID): cv.use_id(CanbusComponent),
cv.Optional(CONF_CAN_ID): cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
cv.Optional(CONF_REMOTE_TRANSMISSION_REQUEST, default=False):
cv.boolean,
cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
},
validate_id,
key=CONF_DATA,
),
)
async def canbus_action_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
await cg.register_parented(var, config[CONF_CANBUS_ID])
if CONF_CAN_ID in config:
can_id = await cg.templatable(config[CONF_CAN_ID], args, cg.uint32)
cg.add(var.set_can_id(can_id))
use_extended_id = await cg.templatable(config[CONF_USE_EXTENDED_ID], args,
cg.uint32)
payloads.append(payload)
yield payloads
@coroutine
def templated_payload_setter_to_code(type, config, payload_id, template_arg,
args):
template_arg = cg.TemplateArguments(type, *[arg[0] for arg in args])
var = cg.new_Pvariable(payload_id, template_arg, args)
yield var
@register_payload_setter(c.PAYLOAD_BOOL, t.TemplatePayloadSetter,
cv.maybe_simple_value(cv.Schema({
cv.GenerateID():
cv.declare_id(t.TemplatePayloadSetter),
}),
key=ehc.CONF_ID))
@coroutine
def bool_payload_setter_to_code(config, payload_id, template_arg, args):
yield templated_payload_setter_to_code(cg.bool_, config, payload_id,
template_arg, args)
@register_payload_setter(c.PAYLOAD_FLOAT, t.TemplatePayloadSetter,
cv.maybe_simple_value(cv.Schema({
cv.GenerateID():
cv.declare_id(t.TemplatePayloadSetter),
}),
key=ehc.CONF_ID))
@coroutine
for key, value in config[CONF_DATA].items():
templ = await cg.templatable(value, args, None)
cg.add(var.add_data(key, templ))
for key, value in config[CONF_DATA_TEMPLATE].items():
templ = await cg.templatable(value, args, None)
cg.add(var.add_data_template(key, templ))
for key, value in config[CONF_VARIABLES].items():
templ = await cg.templatable(value, args, None)
cg.add(var.add_variable(key, templ))
return var
HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(APIServer),
cv.Required(CONF_TAG): cv.templatable(cv.string_strict),
},
key=CONF_TAG,
)
@automation.register_action(
"homeassistant.tag_scanned",
HomeAssistantServiceCallAction,
HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA,
)
async def homeassistant_tag_scanned_to_code(config, action_id, template_arg,
args):
serv = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, serv, True)
cg.add(var.set_service("esphome.tag_scanned"))
def validate_version(value):
parse_firmware_version(value)
return value
CONFIG_SCHEMA = (
light.BRIGHTNESS_ONLY_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID):
cv.declare_id(ShellyDimmer),
cv.Optional(CONF_FIRMWARE, default="51.6"):
cv.maybe_simple_value(
{
cv.Optional(CONF_URL): cv.url,
cv.Optional(CONF_SHA256): validate_sha256,
cv.Required(CONF_VERSION): validate_version,
cv.Optional(CONF_UPDATE, default=False): cv.boolean,
},
validate_firmware, # converts a simple version key to generate the full url
key=CONF_VERSION,
),
cv.Optional(CONF_NRST_PIN, default="GPIO5"):
pins.gpio_output_pin_schema,
cv.Optional(CONF_BOOT0_PIN, default="GPIO4"):
pins.gpio_output_pin_schema,
cv.Optional(CONF_LEADING_EDGE, default=False):
cv.boolean,
cv.Optional(CONF_WARMUP_BRIGHTNESS, default=100):
cv.uint16_t,
# cv.Optional(CONF_WARMUP_TIME, default=20): cv.uint16_t,
cv.Optional(CONF_MIN_BRIGHTNESS, default=0):
cv.uint16_t,