def validator(value):
value = cv.ensure_list(value)
names = set()
ret = []
for i, effect in enumerate(value):
if not isinstance(effect, dict):
raise vol.Invalid(
"Each effect must be a dictionary, not {}".format(
type(value)))
if len(effect) > 1:
raise vol.Invalid(
"Each entry in the 'effects:' option must be a single effect."
)
if not effect:
raise vol.Invalid(
"Found no effect for the {}th entry in 'effects:'!".format(
i))
key = next(iter(effect.keys()))
if key not in allowed_effects:
raise vol.Invalid(
"The effect '{}' does not exist or is not allowed for this "
"light type".format(key))
effect[key] = effect[key] or {}
conf = EFFECTS_SCHEMA(effect)
name = conf[key][CONF_NAME]
if name in names:
raise vol.Invalid(
u"Found the effect name '{}' twice. All effects must have "
u"unique names".format(name))
names.add(name)
ret.append(conf)
return ret
def validate_recursive_action(value):
value = cv.ensure_list(value)[:]
for i, item in enumerate(value):
item = copy.deepcopy(item)
if not isinstance(item, dict):
raise vol.Invalid(
u"Action must consist of key-value mapping! Got {}".format(
item))
key = next((x for x in item if x != CONF_ACTION_ID), None)
if key is None:
raise vol.Invalid(u"Key missing from action! Got {}".format(item))
if key not in ACTION_REGISTRY:
raise vol.Invalid(
u"Unable to find action with the name '{}', is the component loaded?"
u"".format(key))
item.setdefault(CONF_ACTION_ID, None)
key2 = next((x for x in item if x != CONF_ACTION_ID and x != key),
None)
if key2 is not None:
raise vol.Invalid(
u"Cannot have two actions in one item. Key '{}' overrides '{}'! "
u"Did you forget to indent the action?"
u"".format(key, key2))
validator = ACTION_REGISTRY[key][0]
value[i] = {
CONF_ACTION_ID:
cv.declare_variable_id(Action)(item[CONF_ACTION_ID]),
key: validator(item[key])
}
return value
def validate(config):
if CONF_PASSWORD in config and CONF_SSID not in config:
raise vol.Invalid("Cannot have WiFi password without SSID!")
if CONF_SSID in config:
network = {CONF_SSID: config.pop(CONF_SSID)}
if CONF_PASSWORD in config:
network[CONF_PASSWORD] = config.pop(CONF_PASSWORD)
if CONF_NETWORKS in config:
raise vol.Invalid(
"You cannot use the 'ssid:' option together with 'networks:'. Please "
"copy your network into the 'networks:' key")
config[CONF_NETWORKS] = cv.ensure_list(WIFI_NETWORK_STA)(network)
if (CONF_NETWORKS not in config) and (CONF_AP not in config):
raise vol.Invalid("Please specify at least an SSID or an Access Point "
"to create.")
if config.get(CONF_FAST_CONNECT, False):
networks = config.get(CONF_NETWORKS, [])
if not networks:
raise vol.Invalid(
"At least one network required for fast_connect!")
if len(networks) != 1:
raise vol.Invalid(
"Fast connect can only be used with one network!")
return config
def validate_recursive_condition(value):
is_list = isinstance(value, list)
value = cv.ensure_list()(value)[:]
for i, item in enumerate(value):
path = [i] if is_list else []
item = copy.deepcopy(item)
if not isinstance(item, dict):
raise vol.Invalid(u"Condition must consist of key-value mapping! Got {}".format(item),
path)
key = next((x for x in item if x != CONF_CONDITION_ID), None)
if key is None:
raise vol.Invalid(u"Key missing from action! Got {}".format(item), path)
if key not in CONDITION_REGISTRY:
raise vol.Invalid(u"Unable to find condition with the name '{}', is the "
u"component loaded?".format(key), path + [key])
item.setdefault(CONF_CONDITION_ID, None)
key2 = next((x for x in item if x not in (CONF_CONDITION_ID, key)), None)
if key2 is not None:
raise vol.Invalid(u"Cannot have two conditions in one item. Key '{}' overrides '{}'! "
u"Did you forget to indent the block inside the condition?"
u"".format(key, key2), path)
validator = CONDITION_REGISTRY[key][0]
try:
condition = validator(item[key])
except vol.Invalid as err:
err.prepend(path)
raise err
value[i] = {
CONF_CONDITION_ID: cv.declare_variable_id(Condition)(item[CONF_CONDITION_ID]),
key: condition,
}
return value
def validate(config):
if CONF_PASSWORD in config and CONF_SSID not in config:
raise vol.Invalid("Cannot have WiFi password without SSID!")
if CONF_SSID in config:
network = {CONF_SSID: config.pop(CONF_SSID)}
if CONF_PASSWORD in config:
network[CONF_PASSWORD] = config.pop(CONF_PASSWORD)
if CONF_NETWORKS in config:
raise vol.Invalid(
"You cannot use the 'ssid:' option together with 'networks:'. Please "
"copy your network into the 'networks:' key")
config[CONF_NETWORKS] = cv.ensure_list(WIFI_NETWORK_STA)(network)
if (CONF_NETWORKS not in config) and (CONF_AP not in config):
raise vol.Invalid("Please specify at least an SSID or an Access Point "
"to create.")
return config
from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_COMPONENTS
from esphomeyaml.cpp_generator import process_lambda, variable
from esphomeyaml.cpp_helpers import setup_component
from esphomeyaml.cpp_types import Component, ComponentPtr, esphomelib_ns, std_vector
CustomComponentConstructor = esphomelib_ns.class_('CustomComponentConstructor')
MULTI_CONF = True
CONFIG_SCHEMA = vol.Schema({
cv.GenerateID():
cv.declare_variable_id(CustomComponentConstructor),
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_COMPONENTS):
cv.ensure_list(
vol.Schema({
cv.GenerateID(): cv.declare_variable_id(Component)
}).extend(cv.COMPONENT_SCHEMA.schema)),
})
def to_code(config):
for template_ in process_lambda(
config[CONF_LAMBDA], [],
return_type=std_vector.template(ComponentPtr)):
yield
rhs = CustomComponentConstructor(template_)
custom = variable(config[CONF_ID], rhs)
for i, comp in enumerate(config.get(CONF_COMPONENTS, [])):
setup_component(custom.get_component(i), comp)
CONFIG_SCHEMA = vol.Schema({
cv.GenerateID():
cv.declare_variable_id(DeepSleepComponent),
vol.Optional(CONF_SLEEP_DURATION):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_WAKEUP_PIN):
vol.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema,
validate_pin_number),
vol.Optional(CONF_WAKEUP_PIN_MODE):
vol.All(cv.only_on_esp32, cv.one_of(*WAKEUP_PIN_MODES), upper=True),
vol.Optional(CONF_ESP32_EXT1_WAKEUP):
vol.All(
cv.only_on_esp32,
vol.Schema({
vol.Required(CONF_PINS):
cv.ensure_list(pins.shorthand_input_pin, validate_pin_number),
vol.Required(CONF_MODE):
cv.one_of(*EXT1_WAKEUP_MODES, upper=True),
})),
vol.Optional(CONF_RUN_CYCLES):
cv.positive_int,
vol.Optional(CONF_RUN_DURATION):
cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_deep_sleep_component()
deep_sleep = Pvariable(config[CONF_ID], rhs)
if CONF_SLEEP_DURATION in config:
add(deep_sleep.set_sleep_duration(config[CONF_SLEEP_DURATION]))
from esphomeyaml.cpp_types import std_vector
CustomBinaryOutputConstructor = output.output_ns.class_(
'CustomBinaryOutputConstructor')
CustomFloatOutputConstructor = output.output_ns.class_(
'CustomFloatOutputConstructor')
BINARY_SCHEMA = output.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(CustomBinaryOutputConstructor),
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Required(CONF_OUTPUTS):
cv.ensure_list(
output.BINARY_OUTPUT_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(output.BinaryOutput),
})),
})
FLOAT_SCHEMA = output.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(CustomFloatOutputConstructor),
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Required(CONF_OUTPUTS):
cv.ensure_list(
output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(output.FloatOutput),
})),
import esphomeyaml.config_validation as cv
from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_SWITCHES
from esphomeyaml.cpp_generator import process_lambda, variable
from esphomeyaml.cpp_types import std_vector
CustomSwitchConstructor = switch.switch_ns.class_('CustomSwitchConstructor')
PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(CustomSwitchConstructor),
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Required(CONF_SWITCHES):
cv.ensure_list(
switch.SWITCH_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(switch.Switch),
})),
})
def to_code(config):
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=std_vector.template(
switch.SwitchPtr)):
yield
rhs = CustomSwitchConstructor(template_)
custom = variable(config[CONF_ID], rhs)
for i, sens in enumerate(config[CONF_SWITCHES]):
switch.register_switch(custom.get_switch(i), sens)
matches = re.findall(cfmt, value[CONF_FORMAT], flags=re.X)
if len(matches) != len(value[CONF_ARGS]):
raise vol.Invalid(
u"Found {} printf-patterns ({}), but {} args were given!"
u"".format(len(matches), u', '.join(matches),
len(value[CONF_ARGS])))
return value
CONF_LOGGER_LOG = 'logger.log'
LOGGER_LOG_ACTION_SCHEMA = vol.All(
maybe_simple_message({
vol.Required(CONF_FORMAT):
cv.string,
vol.Optional(CONF_ARGS, default=list):
cv.ensure_list(cv.lambda_),
vol.Optional(CONF_LEVEL, default="DEBUG"):
cv.one_of(*LOG_LEVEL_TO_ESP_LOG, upper=True),
vol.Optional(CONF_TAG, default="main"):
cv.string,
}), validate_printf)
@ACTION_REGISTRY.register(CONF_LOGGER_LOG, LOGGER_LOG_ACTION_SCHEMA)
def logger_log_action_to_code(config, action_id, arg_type, template_arg):
esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
args = [RawExpression(text_type(x)) for x in config[CONF_ARGS]]
text = text_type(
statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args)))
from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_TEXT_SENSORS
from esphomeyaml.cpp_generator import process_lambda, variable
from esphomeyaml.cpp_types import std_vector
CustomTextSensorConstructor = text_sensor.text_sensor_ns.class_(
'CustomTextSensorConstructor')
PLATFORM_SCHEMA = text_sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(CustomTextSensorConstructor),
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Required(CONF_TEXT_SENSORS):
cv.ensure_list(
text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(text_sensor.TextSensor),
})),
})
def to_code(config):
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=std_vector.template(
text_sensor.TextSensorPtr)):
yield
rhs = CustomTextSensorConstructor(template_)
custom = variable(config[CONF_ID], rhs)
for i, sens in enumerate(config[CONF_TEXT_SENSORS]):
text_sensor.register_text_sensor(custom.get_text_sensor(i), sens)
def validate_dumpers_all(value):
if not isinstance(value, string_types):
raise vol.Invalid("Not valid dumpers")
if value.upper() == "ALL":
return list(sorted(list(DUMPERS)))
raise vol.Invalid("Not valid dumpers")
CONFIG_SCHEMA = vol.Schema({
cv.GenerateID():
cv.declare_variable_id(RemoteReceiverComponent),
vol.Required(CONF_PIN):
pins.gpio_input_pin_schema,
vol.Optional(CONF_DUMP, default=[]):
vol.Any(validate_dumpers_all,
cv.ensure_list(cv.one_of(*DUMPERS, lower=True))),
vol.Optional(CONF_TOLERANCE):
vol.All(cv.percentage_int, vol.Range(min=0)),
vol.Optional(CONF_BUFFER_SIZE):
cv.validate_bytes,
vol.Optional(CONF_FILTER):
cv.positive_time_period_microseconds,
vol.Optional(CONF_IDLE):
cv.positive_time_period_microseconds,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for pin in gpio_input_pin_expression(config[CONF_PIN]):
yield
rhs = App.make_remote_receiver_component(pin)
Filter = binary_sensor_ns.class_('Filter')
DelayedOnFilter = binary_sensor_ns.class_('DelayedOnFilter', Filter, Component)
DelayedOffFilter = binary_sensor_ns.class_('DelayedOffFilter', Filter,
Component)
HeartbeatFilter = binary_sensor_ns.class_('HeartbeatFilter', Filter, Component)
InvertFilter = binary_sensor_ns.class_('InvertFilter', Filter)
LambdaFilter = binary_sensor_ns.class_('LambdaFilter', Filter)
FILTER_KEYS = [
CONF_INVERT, CONF_DELAYED_ON, CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT
]
FILTERS_SCHEMA = cv.ensure_list(
{
vol.Optional(CONF_INVERT): None,
vol.Optional(CONF_DELAYED_ON): cv.positive_time_period_milliseconds,
vol.Optional(CONF_DELAYED_OFF): cv.positive_time_period_milliseconds,
vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
vol.Optional(CONF_LAMBDA): cv.lambda_,
}, cv.has_exactly_one_key(*FILTER_KEYS))
MULTI_CLICK_TIMING_SCHEMA = vol.Schema({
vol.Optional(CONF_STATE):
cv.boolean,
vol.Optional(CONF_MIN_LENGTH):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_MAX_LENGTH):
cv.positive_time_period_milliseconds,
})
def parse_multi_click_timing_str(value):
(?:h|l|ll|w|I|I32|I64)? # size
[cCdiouxXeEfgGaAnpsSZ] # type
) | # OR
%%) # literal "%%"
""" # noqa
matches = re.findall(cfmt, value[CONF_FORMAT], flags=re.X)
if len(matches) != len(value[CONF_ARGS]):
raise vol.Invalid(u"Found {} printf-patterns ({}), but {} args were given!"
u"".format(len(matches), u', '.join(matches), len(value[CONF_ARGS])))
return value
CONF_LOGGER_LOG = 'logger.log'
LOGGER_LOG_ACTION_SCHEMA = vol.All(maybe_simple_message({
vol.Required(CONF_FORMAT): cv.string,
vol.Optional(CONF_ARGS, default=list): cv.ensure_list(cv.lambda_),
vol.Optional(CONF_LEVEL, default="DEBUG"): cv.one_of(*LOG_LEVEL_TO_ESP_LOG, upper=True),
vol.Optional(CONF_TAG, default="main"): cv.string,
}), validate_printf)
@ACTION_REGISTRY.register(CONF_LOGGER_LOG, LOGGER_LOG_ACTION_SCHEMA)
def logger_log_action_to_code(config, action_id, arg_type, template_arg):
esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
args = [RawExpression(text_type(x)) for x in config[CONF_ARGS]]
text = text_type(statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args)))
for lambda_ in process_lambda(Lambda(text), [(arg_type, 'x')], return_type=void):
yield None
rhs = LambdaAction.new(template_arg, lambda_)
from esphomeyaml.components import binary_sensor
import esphomeyaml.config_validation as cv
from esphomeyaml.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA
from esphomeyaml.cpp_generator import process_lambda, variable
from esphomeyaml.cpp_types import std_vector
CustomBinarySensorConstructor = binary_sensor.binary_sensor_ns.class_(
'CustomBinarySensorConstructor')
PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CustomBinarySensorConstructor),
vol.Required(CONF_LAMBDA): cv.lambda_,
vol.Required(CONF_BINARY_SENSORS):
cv.ensure_list(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(binary_sensor.BinarySensor),
})),
})
def to_code(config):
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=std_vector.template(binary_sensor.BinarySensorPtr)):
yield
rhs = CustomBinarySensorConstructor(template_)
custom = variable(config[CONF_ID], rhs)
for i, sens in enumerate(config[CONF_BINARY_SENSORS]):
binary_sensor.register_binary_sensor(custom.get_binary_sensor(i), sens)
import voluptuous as vol
from esphomeyaml.components import sensor
import esphomeyaml.config_validation as cv
from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_SENSORS
from esphomeyaml.cpp_generator import process_lambda, variable
from esphomeyaml.cpp_types import std_vector
CustomSensorConstructor = sensor.sensor_ns.class_('CustomSensorConstructor')
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CustomSensorConstructor),
vol.Required(CONF_LAMBDA): cv.lambda_,
vol.Required(CONF_SENSORS): cv.ensure_list(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
})),
})
def to_code(config):
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=std_vector.template(sensor.SensorPtr)):
yield
rhs = CustomSensorConstructor(template_)
custom = variable(config[CONF_ID], rhs)
for i, sens in enumerate(config[CONF_SENSORS]):
sensor.register_sensor(custom.get_sensor(i), sens)
BUILD_FLAGS = '-DUSE_CUSTOM_SENSOR'
vol.Optional(CONF_PLATFORMIO_OPTIONS): vol.Schema({
cv.string_strict: vol.Any([cv.string], cv.string),
}),
vol.Optional(CONF_BOARD_FLASH_MODE): cv.one_of(*BUILD_FLASH_MODES, lower=True),
vol.Optional(CONF_ON_BOOT): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StartupTrigger),
vol.Optional(CONF_PRIORITY): cv.float_,
}),
vol.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ShutdownTrigger),
}),
vol.Optional(CONF_ON_LOOP): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(LoopTrigger),
}),
vol.Optional(CONF_INCLUDES): cv.ensure_list(cv.file_),
vol.Optional(CONF_LIBRARIES): cv.ensure_list(cv.string_strict),
vol.Optional('library_uri'): cv.invalid("The library_uri option has been removed in 1.8.0 and "
"was moved into the esphomelib_version option."),
vol.Optional('use_build_flags'): cv.invalid("The use_build_flags option has been replaced by "
"use_custom_code option in 1.8.0."),
})
def preload_core_config(config):
if CONF_ESPHOMEYAML not in config:
raise EsphomeyamlError(u"No esphomeyaml section in config")
core_conf = config[CONF_ESPHOMEYAML]
if CONF_PLATFORM not in core_conf:
raise EsphomeyamlError("esphomeyaml.platform not specified.")
vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_RANDOM): vol.Schema({
cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(RandomLightEffect),
vol.Optional(CONF_NAME, default="Random"): cv.string,
vol.Optional(CONF_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_STROBE): vol.Schema({
cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(StrobeLightEffect),
vol.Optional(CONF_NAME, default="Strobe"): cv.string,
vol.Optional(CONF_COLORS): vol.All(cv.ensure_list(vol.Schema({
vol.Optional(CONF_STATE, default=True): cv.boolean,
vol.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
vol.Optional(CONF_RED, default=1.0): cv.percentage,
vol.Optional(CONF_GREEN, default=1.0): cv.percentage,
vol.Optional(CONF_BLUE, default=1.0): cv.percentage,
vol.Optional(CONF_WHITE, default=1.0): cv.percentage,
vol.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)), vol.Length(min=2)),
}),
vol.Optional(CONF_FLICKER): vol.Schema({
cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FlickerLightEffect),
vol.Optional(CONF_NAME, default="Flicker"): cv.string,
vol.Optional(CONF_ALPHA): cv.percentage,
vol.Optional(CONF_INTENSITY): cv.percentage,
}),
vol.Optional(CONF_ADDRESSABLE_LAMBDA): vol.Schema({
vol.Required(CONF_NAME): cv.string,
vol.Required(CONF_LAMBDA): cv.lambda_,
vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
FILTERS_SCHEMA = cv.ensure_list(
{
vol.Optional(CONF_OFFSET):
cv.float_,
vol.Optional(CONF_MULTIPLY):
cv.float_,
vol.Optional(CONF_FILTER_OUT):
cv.float_,
vol.Optional(CONF_FILTER_NAN):
None,
vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE):
vol.All(
vol.Schema({
vol.Optional(CONF_WINDOW_SIZE, default=15):
cv.positive_not_null_int,
vol.Optional(CONF_SEND_EVERY, default=15):
cv.positive_not_null_int,
vol.Optional(CONF_SEND_FIRST_AT):
cv.positive_not_null_int,
}), validate_send_first_at),
vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE):
vol.Schema({
vol.Optional(CONF_ALPHA, default=0.1):
cv.positive_float,
vol.Optional(CONF_SEND_EVERY, default=15):
cv.positive_not_null_int,
}),
vol.Optional(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_THROTTLE):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_DELTA):
cv.float_,
vol.Optional(CONF_UNIQUE):
None,
vol.Optional(CONF_HEARTBEAT):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_DEBOUNCE):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_OR):
validate_recursive_filter,
}, cv.has_exactly_one_key(*FILTER_KEYS))
import voluptuous as vol
from esphomeyaml.components import time as time_
import esphomeyaml.config_validation as cv
from esphomeyaml.const import CONF_ID, CONF_SERVERS
from esphomeyaml.cpp_generator import Pvariable, add
from esphomeyaml.cpp_helpers import setup_component
from esphomeyaml.cpp_types import App
SNTPComponent = time_.time_ns.class_('SNTPComponent', time_.RealTimeClockComponent)
PLATFORM_SCHEMA = time_.TIME_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(SNTPComponent),
vol.Optional(CONF_SERVERS): vol.All(cv.ensure_list(cv.domain), vol.Length(min=1, max=3)),
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_sntp_component()
sntp = Pvariable(config[CONF_ID], rhs)
if CONF_SERVERS in config:
servers = config[CONF_SERVERS]
servers += [''] * (3 - len(servers))
add(sntp.set_servers(*servers))
time_.setup_time(sntp, config)
setup_component(sntp, config)
BUILD_FLAGS = '-DUSE_SNTP_COMPONENT'
MQTT_MESSAGE_SCHEMA,
vol.Optional(CONF_WILL_MESSAGE):
MQTT_MESSAGE_SCHEMA,
vol.Optional(CONF_SHUTDOWN_MESSAGE):
MQTT_MESSAGE_SCHEMA,
vol.Optional(CONF_TOPIC_PREFIX):
cv.publish_topic,
vol.Optional(CONF_LOG_TOPIC):
vol.Any(
None,
MQTT_MESSAGE_BASE.extend({
vol.Optional(CONF_LEVEL):
logger.is_log_level,
}), validate_message_just_topic),
vol.Optional(CONF_SSL_FINGERPRINTS):
vol.All(cv.only_on_esp8266, cv.ensure_list(validate_fingerprint)),
vol.Optional(CONF_KEEPALIVE):
cv.positive_time_period_seconds,
vol.Optional(CONF_REBOOT_TIMEOUT):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_ON_MESSAGE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_variable_id(MQTTMessageTrigger),
vol.Required(CONF_TOPIC):
cv.subscribe_topic,
vol.Optional(CONF_QOS):
cv.mqtt_qos,
vol.Optional(CONF_PAYLOAD):
cv.string_strict,
}),
if not networks:
raise vol.Invalid(
"At least one network required for fast_connect!")
if len(networks) != 1:
raise vol.Invalid(
"Fast connect can only be used with one network!")
return config
CONFIG_SCHEMA = vol.All(
vol.Schema({
cv.GenerateID():
cv.declare_variable_id(WiFiComponent),
vol.Optional(CONF_NETWORKS):
cv.ensure_list(WIFI_NETWORK_STA),
vol.Optional(CONF_SSID):
cv.ssid,
vol.Optional(CONF_PASSWORD):
validate_password,
vol.Optional(CONF_MANUAL_IP):
STA_MANUAL_IP_SCHEMA,
vol.Optional(CONF_AP):
WIFI_NETWORK_AP,
vol.Optional(CONF_HOSTNAME):
cv.hostname,
vol.Optional(CONF_DOMAIN, default='.local'):
cv.domain_name,
vol.Optional(CONF_REBOOT_TIMEOUT):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_POWER_SAVE_MODE):
