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_recursive_action(value): is_list = isinstance(value, list) if not is_list: value = [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"Action must consist of key-value mapping! Got {}".format(item), path) 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), path) if key not in ACTION_REGISTRY: raise vol.Invalid(u"Unable to find action with the name '{}', is the component loaded?" u"".format(key), path + [key]) item.setdefault(CONF_ACTION_ID, None) key2 = next((x for x in item if x not in (CONF_ACTION_ID, 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 block inside the action?" u"".format(key, key2), path) validator = ACTION_REGISTRY[key][0] try: action = validator(item[key]) except vol.Invalid as err: err.prepend(path) raise err value[i] = { CONF_ACTION_ID: cv.declare_variable_id(Action)(item[CONF_ACTION_ID]), key: action, } return value
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml import automation from esphomeyaml.components import cover from esphomeyaml.const import CONF_CLOSE_ACTION, CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, \ CONF_OPEN_ACTION, CONF_STOP_ACTION, CONF_OPTIMISTIC from esphomeyaml.helpers import App, Application, NoArg, add, process_lambda, variable, optional MakeTemplateCover = Application.MakeTemplateCover PLATFORM_SCHEMA = vol.All( cover.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateCover), vol.Optional(CONF_LAMBDA): cv.lambda_, vol.Optional(CONF_OPTIMISTIC): cv.boolean, vol.Optional(CONF_OPEN_ACTION): automation.ACTIONS_SCHEMA, vol.Optional(CONF_CLOSE_ACTION): automation.ACTIONS_SCHEMA, vol.Optional(CONF_STOP_ACTION): automation.ACTIONS_SCHEMA, }).extend(cover.COVER_SCHEMA.schema), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC)) def to_code(config): rhs = App.make_template_cover(config[CONF_NAME])
def validate_adc_pin(value): vcc = str(value).upper() if vcc == 'VCC': return cv.only_on_esp8266(vcc) return pins.analog_pin(value) MakeADCSensor = Application.struct('MakeADCSensor') ADCSensorComponent = sensor.sensor_ns.class_('ADCSensorComponent', sensor.PollingSensorComponent) PLATFORM_SCHEMA = cv.nameable( sensor.SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(ADCSensorComponent), cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeADCSensor), vol.Required(CONF_PIN): validate_adc_pin, vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES, lower=True)), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }).extend(cv.COMPONENT_SCHEMA.schema)) def to_code(config): pin = config[CONF_PIN] if pin == 'VCC': pin = 0
'TLK110': EthernetType.ETHERNET_TYPE_TLK110, } eth_clock_mode_t = global_ns.enum('eth_clock_mode_t') CLK_MODES = { 'GPIO0_IN': eth_clock_mode_t.ETH_CLOCK_GPIO0_IN, 'GPIO0_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO0_OUT, 'GPIO16_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO16_OUT, 'GPIO17_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO17_OUT, } EthernetComponent = esphomelib_ns.class_('EthernetComponent', Component) CONFIG_SCHEMA = vol.Schema({ cv.GenerateID(): cv.declare_variable_id(EthernetComponent), vol.Required(CONF_TYPE): cv.one_of(*ETHERNET_TYPES, upper=True), vol.Required(CONF_MDC_PIN): pins.output_pin, vol.Required(CONF_MDIO_PIN): pins.input_output_pin, vol.Optional(CONF_CLK_MODE, default='GPIO0_IN'): cv.one_of(*CLK_MODES, upper=True, space='_'), vol.Optional(CONF_PHY_ADDR, default=0): vol.All(cv.int_, vol.Range(min=0, max=31)), vol.Optional(CONF_POWER_PIN): pins.gpio_output_pin_schema, vol.Optional(CONF_MANUAL_IP): wifi.STA_MANUAL_IP_SCHEMA, vol.Optional(CONF_HOSTNAME):
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml import automation from esphomeyaml.components import switch from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_TURN_OFF_ACTION, \ CONF_TURN_ON_ACTION, CONF_OPTIMISTIC from esphomeyaml.helpers import App, Application, process_lambda, variable, NoArg, add, bool_, \ optional MakeTemplateSwitch = Application.MakeTemplateSwitch PLATFORM_SCHEMA = vol.All( switch.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateSwitch), vol.Optional(CONF_LAMBDA): cv.lambda_, vol.Optional(CONF_OPTIMISTIC): cv.boolean, vol.Optional(CONF_TURN_OFF_ACTION): automation.ACTIONS_SCHEMA, vol.Optional(CONF_TURN_ON_ACTION): automation.ACTIONS_SCHEMA, }).extend(switch.SWITCH_SCHEMA.schema), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC)) def to_code(config): rhs = App.make_template_switch(config[CONF_NAME]) make = variable(config[CONF_MAKE_ID], rhs)
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import sensor from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32 from esphomeyaml.helpers import App, Application, variable ESP_PLATFORMS = [ESP_PLATFORM_ESP32] MakeESP32HallSensor = Application.MakeESP32HallSensor PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeESP32HallSensor), vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds, }).extend(sensor.SENSOR_SCHEMA.schema) def to_code(config): rhs = App.make_esp32_hall_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL)) make = variable(config[CONF_MAKE_ID], rhs) sensor.setup_sensor(make.Phall, make.Pmqtt, config) BUILD_FLAGS = '-DUSE_ESP32_HALL_SENSOR'
try: import pytz return convert_tz(pytz.timezone(value)) except Exception: # pylint: disable=broad-except return value TIME_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_TIMEZONE, default=detect_tz): validate_tz, vol.Optional(CONF_ON_TIME): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(CronTrigger), vol.Optional(CONF_SECONDS): validate_cron_seconds, vol.Optional(CONF_MINUTES): validate_cron_minutes, vol.Optional(CONF_HOURS): validate_cron_hours, vol.Optional(CONF_DAYS_OF_MONTH): validate_cron_days_of_month, vol.Optional(CONF_MONTHS): validate_cron_months, vol.Optional(CONF_DAYS_OF_WEEK): validate_cron_days_of_week, vol.Optional(CONF_CRON): validate_cron_raw, }, validate_cron_keys), }) def setup_time_core_(time_var, config): add(time_var.set_timezone(config[CONF_TIMEZONE])) for conf in config.get(CONF_ON_TIME, []):
if CONF_SSID 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 # pylint: disable=invalid-name IPAddress = global_ns.IPAddress ManualIP = esphomelib_ns.ManualIP WiFiComponent = esphomelib_ns.WiFiComponent WiFiAp = esphomelib_ns.WiFiAp CONFIG_SCHEMA = vol.All( vol.Schema({ cv.GenerateID(): cv.declare_variable_id(WiFiComponent), 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.domainname, vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds, }), validate)
frequency = obj.get(CONF_FREQUENCY, 1000) bit_depth = obj.get(CONF_BIT_DEPTH, 12) max_freq = APB_CLOCK_FREQ / (2**bit_depth) if frequency > max_freq: raise vol.Invalid('Maximum frequency for bit depth {} is {}Hz'.format( bit_depth, max_freq)) return obj LEDCOutputComponent = output.output_ns.class_('LEDCOutputComponent', output.FloatOutput, Component) PLATFORM_SCHEMA = vol.All( output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({ vol.Required(CONF_ID): cv.declare_variable_id(LEDCOutputComponent), vol.Required(CONF_PIN): pins.output_pin, vol.Optional(CONF_FREQUENCY): cv.frequency, vol.Optional(CONF_BIT_DEPTH): vol.All(vol.Coerce(int), vol.Range(min=1, max=15)), vol.Optional(CONF_CHANNEL): vol.All(vol.Coerce(int), vol.Range(min=0, max=15)) }).extend(cv.COMPONENT_SCHEMA.schema), validate_frequency_bit_depth) def to_code(config): frequency = config.get(CONF_FREQUENCY) if frequency is None and CONF_BIT_DEPTH in config: frequency = 1000
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import sensor from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \ make_address_array from esphomeyaml.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_MAKE_ID, \ CONF_NAME, CONF_TEMPERATURE from esphomeyaml.helpers import Pvariable, esphomelib_ns, get_variable DEPENDENCIES = ['esp32_ble_tracker'] XiaomiDevice = esphomelib_ns.XiaomiDevice PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(XiaomiDevice), cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker), vol.Required(CONF_MAC_ADDRESS): cv.mac_address, vol.Optional(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA), vol.Optional(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA), vol.Optional(CONF_BATTERY_LEVEL): cv.nameable(sensor.SENSOR_SCHEMA), }) def to_code(config): hub = None for hub in get_variable(config[CONF_ESP32_BLE_ID]): yield rhs = hub.make_xiaomi_device(make_address_array(config[CONF_MAC_ADDRESS])) dev = Pvariable(config[CONF_MAKE_ID], rhs) if CONF_TEMPERATURE in config:
cv.string, vol.Required(CONF_BOARD): cv.string, vol.Optional(CONF_LIBRARY_URI, default=DEFAULT_LIBRARY_URI): cv.string, vol.Optional(CONF_SIMPLIFY, default=True): cv.boolean, vol.Optional(CONF_USE_BUILD_FLAGS, default=True): cv.boolean, vol.Optional(CONF_BOARD_FLASH_MODE): vol.All(vol.Lower, cv.one_of(*BUILD_FLASH_MODES)), vol.Optional(CONF_ON_BOOT): vol.All(cv.ensure_list, [ automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StartupTrigger), vol.Optional(CONF_PRIORITY): vol.Coerce(float), }) ]), vol.Optional(CONF_ON_SHUTDOWN): vol.All(cv.ensure_list, [ automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ShutdownTrigger), }) ]), }) REQUIRED_COMPONENTS = [CONF_ESPHOMEYAML, CONF_WIFI]
TemplateArguments, get_variable, Nameable, Action PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({}) switch_ns = esphomelib_ns.namespace('switch_') Switch = switch_ns.class_('Switch', Nameable) MQTTSwitchComponent = switch_ns.class_('MQTTSwitchComponent', mqtt.MQTTComponent) ToggleAction = switch_ns.class_('ToggleAction', Action) TurnOffAction = switch_ns.class_('TurnOffAction', Action) TurnOnAction = switch_ns.class_('TurnOnAction', Action) SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({ cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSwitchComponent), vol.Optional(CONF_ICON): cv.icon, vol.Optional(CONF_INVERTED): cv.boolean, }) SWITCH_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SWITCH_SCHEMA.schema) def setup_switch_core_(switch_var, mqtt_var, config): if CONF_INTERNAL in config: add(switch_var.set_internal(config[CONF_INTERNAL])) if CONF_ICON in config: add(switch_var.set_icon(config[CONF_ICON])) if CONF_INVERTED in config:
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml import automation from esphomeyaml.components import cover from esphomeyaml.const import CONF_CLOSE_ACTION, CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, \ CONF_OPEN_ACTION, CONF_STOP_ACTION, CONF_OPTIMISTIC from esphomeyaml.cpp_generator import variable, process_lambda, add from esphomeyaml.cpp_helpers import setup_component from esphomeyaml.cpp_types import Application, App, optional, NoArg MakeTemplateCover = Application.struct('MakeTemplateCover') TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover) PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateCover), cv.GenerateID(): cv.declare_variable_id(TemplateCover), vol.Optional(CONF_LAMBDA): cv.lambda_, vol.Optional(CONF_OPTIMISTIC): cv.boolean, vol.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True), vol.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True), vol.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True), }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC)) def to_code(config): rhs = App.make_template_cover(config[CONF_NAME]) make = variable(config[CONF_MAKE_ID], rhs) cover.setup_cover(make.Ptemplate_, make.Pmqtt, config) setup_component(make.Ptemplate_, config)
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True), }) MakeBME680Sensor = Application.struct('MakeBME680Sensor') BME680TemperatureSensor = sensor.sensor_ns.class_( 'BME680TemperatureSensor', sensor.EmptyPollingParentSensor) BME680PressureSensor = sensor.sensor_ns.class_('BME680PressureSensor', sensor.EmptyPollingParentSensor) BME680HumiditySensor = sensor.sensor_ns.class_('BME680HumiditySensor', sensor.EmptyPollingParentSensor) BME680GasResistanceSensor = sensor.sensor_ns.class_( 'BME680GasResistanceSensor', sensor.EmptyPollingParentSensor) PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBME680Sensor), vol.Optional(CONF_ADDRESS, default=0x76): cv.i2c_address, vol.Required(CONF_TEMPERATURE): cv.nameable( BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(BME680TemperatureSensor), })), vol.Required(CONF_PRESSURE): cv.nameable( BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(BME680PressureSensor), })), vol.Required(CONF_HUMIDITY):
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import sensor from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_PRESSURE, \ CONF_TEMPERATURE, CONF_UPDATE_INTERVAL from esphomeyaml.helpers import App, Application, add, variable DEPENDENCIES = ['i2c'] MakeMS5611Sensor = Application.MakeMS5611Sensor PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMS5611Sensor), vol.Optional(CONF_ADDRESS): cv.i2c_address, vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA), vol.Required(CONF_PRESSURE): cv.nameable(sensor.SENSOR_SCHEMA), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }) def to_code(config): rhs = App.make_ms5611_sensor(config[CONF_TEMPERATURE][CONF_NAME], config[CONF_PRESSURE][CONF_NAME], config.get(CONF_UPDATE_INTERVAL)) make = variable(config[CONF_MAKE_ID], rhs)
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import fan, output from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT from esphomeyaml.helpers import App, add, get_variable, variable, setup_component PLATFORM_SCHEMA = cv.nameable( fan.FAN_PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan), vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput), vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput), }).extend(cv.COMPONENT_SCHEMA.schema)) def to_code(config): for output_ in get_variable(config[CONF_OUTPUT]): yield rhs = App.make_fan(config[CONF_NAME]) fan_struct = variable(config[CONF_MAKE_ID], rhs) add(fan_struct.Poutput.set_binary(output_)) if CONF_OSCILLATION_OUTPUT in config: for oscillation_output in get_variable( config[CONF_OSCILLATION_OUTPUT]): yield add(fan_struct.Poutput.set_oscillation(oscillation_output))
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import light from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \ CONF_NAME, CONF_OUTPUT from esphomeyaml.helpers import App, get_variable, variable PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight), vol.Required(CONF_OUTPUT): cv.use_variable_id(None), vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float, vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds, })) def to_code(config): output = None for output in get_variable(config[CONF_OUTPUT]): yield rhs = App.make_monochromatic_light(config[CONF_NAME], output) light_struct = variable(config[CONF_MAKE_ID], rhs) light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
raise vol.Invalid( "Please specify the internal filter in microseconds now " "(since 1.7.0). For example '17ms'") value = cv.positive_time_period_microseconds(value) if value.total_microseconds > 13: raise vol.Invalid( "Maximum internal filter value for ESP32 is 13us") return value else: return cv.positive_time_period_microseconds(value) PLATFORM_SCHEMA = cv.nameable( sensor.SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakePulseCounterSensor), vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema, vol.Optional(CONF_COUNT_MODE): vol.Schema({ vol.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA, vol.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA, }), vol.Optional(CONF_INTERNAL_FILTER): validate_internal_filter, vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds, vol.Optional(CONF_PULL_MODE): cv.invalid("The pull_mode option has been removed in 1.7.0, " "please use the pin mode schema now.") }))
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import binary_sensor from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME from esphomeyaml.helpers import App, Application, process_lambda, variable, optional, bool_ MakeTemplateBinarySensor = Application.MakeTemplateBinarySensor PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateBinarySensor), vol.Required(CONF_LAMBDA): cv.lambda_, }).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema) def to_code(config): template_ = None for template_ in process_lambda(config[CONF_LAMBDA], [], return_type=optional.template(bool_)): yield rhs = App.make_template_binary_sensor(config[CONF_NAME], template_) make = variable(config[CONF_MAKE_ID], rhs) binary_sensor.setup_binary_sensor(make.Ptemplate_, make.Pmqtt, config) BUILD_FLAGS = '-DUSE_TEMPLATE_BINARY_SENSOR'
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml import pins from esphomeyaml.const import CONF_CLK_PIN, CONF_ID, CONF_MISO_PIN, CONF_MOSI_PIN from esphomeyaml.helpers import App, Pvariable, esphomelib_ns, gpio_input_pin_expression, \ gpio_output_pin_expression, add SPIComponent = esphomelib_ns.SPIComponent SPI_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)) CONFIG_SCHEMA = vol.All(cv.ensure_list, [SPI_SCHEMA]) def to_code(config): for conf in config: clk = None for clk in gpio_output_pin_expression(conf[CONF_CLK_PIN]): yield rhs = App.init_spi(clk) spi = Pvariable(conf[CONF_ID], rhs) if CONF_MISO_PIN in conf: for miso in gpio_input_pin_expression(conf[CONF_MISO_PIN]): yield
from esphomeyaml.components import text_sensor import esphomeyaml.config_validation as cv from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_QOS, CONF_TOPIC from esphomeyaml.helpers import App, Application, add, variable, setup_component, Component DEPENDENCIES = ['mqtt'] MakeMQTTSubscribeTextSensor = Application.struct('MakeMQTTSubscribeTextSensor') MQTTSubscribeTextSensor = text_sensor.text_sensor_ns.class_( 'MQTTSubscribeTextSensor', text_sensor.TextSensor, Component) PLATFORM_SCHEMA = cv.nameable( text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(MQTTSubscribeTextSensor), cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMQTTSubscribeTextSensor), vol.Required(CONF_TOPIC): cv.subscribe_topic, vol.Optional(CONF_QOS): cv.mqtt_qos, }).extend(cv.COMPONENT_SCHEMA.schema)) def to_code(config): rhs = App.make_mqtt_subscribe_text_sensor(config[CONF_NAME], config[CONF_TOPIC]) make = variable(config[CONF_MAKE_ID], rhs) sensor_ = make.Psensor
import esphomeyaml.config_validation as cv from esphomeyaml.components import sensor from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32 from esphomeyaml.cpp_generator import variable from esphomeyaml.cpp_helpers import setup_component from esphomeyaml.cpp_types import Application, App ESP_PLATFORMS = [ESP_PLATFORM_ESP32] MakeESP32TemperatureSensor = Application.struct('MakeESP32TemperatureSensor') ESP32TemperatureSensor = sensor.sensor_ns.class_('ESP32TemperatureSensor', sensor.PollingSensorComponent) PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(ESP32TemperatureSensor), cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeESP32TemperatureSensor), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }).extend(cv.COMPONENT_SCHEMA.schema)) def to_code(config): rhs = App.make_esp32_temperature_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL)) make = variable(config[CONF_MAKE_ID], rhs) sensor.setup_sensor(make.Phall, make.Pmqtt, config) setup_component(make.Phall, config) BUILD_FLAGS = '-DUSE_ESP32_TEMPERATURE_SENSOR'
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import output from esphomeyaml.components.pca9685 import PCA9685OutputComponent from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY from esphomeyaml.helpers import Pvariable, get_variable DEPENDENCIES = ['pca9685'] Channel = PCA9685OutputComponent.Channel PLATFORM_SCHEMA = output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({ vol.Required(CONF_ID): cv.declare_variable_id(Channel), vol.Required(CONF_CHANNEL): vol.All(vol.Coerce(int), vol.Range(min=0, max=15)), cv.GenerateID(CONF_PCA9685_ID): cv.use_variable_id(PCA9685OutputComponent), }) def to_code(config): power_supply = None if CONF_POWER_SUPPLY in config: for power_supply in get_variable(config[CONF_POWER_SUPPLY]): yield pca9685 = None for pca9685 in get_variable(config[CONF_PCA9685_ID]): yield rhs = pca9685.create_channel(config[CONF_CHANNEL], power_supply) out = Pvariable(config[CONF_ID], rhs) output.setup_output_platform(out, config, skip_power_supply=True)
IIR_FILTER_OPTIONS = { 'OFF': sensor.sensor_ns.BME280_IIR_FILTER_OFF, '2X': sensor.sensor_ns.BME280_IIR_FILTER_2X, '4X': sensor.sensor_ns.BME280_IIR_FILTER_4X, '8X': sensor.sensor_ns.BME280_IIR_FILTER_8X, '16X': sensor.sensor_ns.BME280_IIR_FILTER_16X, } BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({ vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)), }) MakeBME280Sensor = Application.MakeBME280Sensor PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBME280Sensor), vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address, vol.Required(CONF_TEMPERATURE): BME280_OVERSAMPLING_SENSOR_SCHEMA, vol.Required(CONF_PRESSURE): BME280_OVERSAMPLING_SENSOR_SCHEMA, vol.Required(CONF_HUMIDITY): BME280_OVERSAMPLING_SENSOR_SCHEMA, vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)), vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds, }) def to_code(config): rhs = App.make_bme280_sensor(config[CONF_TEMPERATURE][CONF_NAME], config[CONF_PRESSURE][CONF_NAME], config[CONF_HUMIDITY][CONF_NAME], config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import binary_sensor, uart from esphomeyaml.const import CONF_ID, CONF_UART_ID from esphomeyaml.helpers import App, Pvariable, get_variable, setup_component, Component DEPENDENCIES = ['uart'] RDM6300Component = binary_sensor.binary_sensor_ns.class_( 'RDM6300Component', Component, uart.UARTDevice) CONFIG_SCHEMA = vol.All(cv.ensure_list_not_empty, [ vol.Schema({ cv.GenerateID(): cv.declare_variable_id(RDM6300Component), cv.GenerateID(CONF_UART_ID): cv.use_variable_id(uart.UARTComponent), }).extend(cv.COMPONENT_SCHEMA.schema) ]) def to_code(config): for conf in config: for uart_ in get_variable(conf[CONF_UART_ID]): yield rhs = App.make_rdm6300_component(uart_) var = Pvariable(conf[CONF_ID], rhs) setup_component(var, conf)
from esphomeyaml.components import output import esphomeyaml.config_validation as cv from esphomeyaml.const import (CONF_BIT_DEPTH, CONF_CLOCK_PIN, CONF_DATA_PIN, CONF_ID, CONF_NUM_CHANNELS, CONF_NUM_CHIPS, CONF_UPDATE_ON_BOOT) from esphomeyaml.cpp_generator import Pvariable, add from esphomeyaml.cpp_helpers import gpio_output_pin_expression, setup_component from esphomeyaml.cpp_types import App, Component MY9231OutputComponent = output.output_ns.class_('MY9231OutputComponent', Component) MULTI_CONF = True CONFIG_SCHEMA = vol.Schema({ cv.GenerateID(): cv.declare_variable_id(MY9231OutputComponent), vol.Required(CONF_DATA_PIN): pins.gpio_output_pin_schema, vol.Required(CONF_CLOCK_PIN): pins.gpio_output_pin_schema, vol.Optional(CONF_NUM_CHANNELS): vol.All(vol.Coerce(int), vol.Range(3, 1020)), vol.Optional(CONF_NUM_CHIPS): vol.All(vol.Coerce(int), vol.Range(1, 255)), vol.Optional(CONF_BIT_DEPTH): cv.one_of(8, 12, 14, 16, int=True), vol.Optional(CONF_UPDATE_ON_BOOT): vol.Coerce(bool), }).extend(cv.COMPONENT_SCHEMA.schema)
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml.components import switch from esphomeyaml.const import CONF_INVERTED, CONF_MAKE_ID, CONF_NAME from esphomeyaml.helpers import App, Application, variable MakeShutdownSwitch = Application.struct('MakeShutdownSwitch') ShutdownSwitch = switch.switch_ns.class_('ShutdownSwitch', switch.Switch) PLATFORM_SCHEMA = cv.nameable( switch.SWITCH_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(ShutdownSwitch), cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeShutdownSwitch), vol.Optional(CONF_INVERTED): cv.invalid("Shutdown switches do not support inverted mode!"), })) def to_code(config): rhs = App.make_shutdown_switch(config[CONF_NAME]) shutdown = variable(config[CONF_MAKE_ID], rhs) switch.setup_switch(shutdown.Pshutdown, shutdown.Pmqtt, config) BUILD_FLAGS = '-DUSE_SHUTDOWN_SWITCH' def to_hass_config(data, config):
import voluptuous as vol import esphomeyaml.config_validation as cv from esphomeyaml import pins from esphomeyaml.components import sensor from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL from esphomeyaml.helpers import App, Application, gpio_input_pin_expression, variable MakeDutyCycleSensor = Application.MakeDutyCycleSensor PLATFORM_SCHEMA = cv.nameable( sensor.SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeDutyCycleSensor), vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema, vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, })) def to_code(config): pin = None for pin in gpio_input_pin_expression(config[CONF_PIN]): yield rhs = App.make_duty_cycle_sensor(config[CONF_NAME], pin, config.get(CONF_UPDATE_INTERVAL)) make = variable(config[CONF_MAKE_ID], rhs) sensor.setup_sensor(make.Pduty, make.Pmqtt, config)
from esphomeyaml.const import CONF_ADDRESS, CONF_CURRENT, CONF_ID, CONF_MAX_CURRENT, \ CONF_MAX_VOLTAGE, CONF_NAME, CONF_POWER, CONF_UPDATE_INTERVAL, CONF_BUS_VOLTAGE, \ CONF_SHUNT_VOLTAGE, CONF_SHUNT_RESISTANCE from esphomeyaml.helpers import App, Pvariable DEPENDENCIES = ['i2c'] INA219Component = sensor.sensor_ns.INA219Component INA219VoltageSensor = sensor.sensor_ns.INA219VoltageSensor INA219CurrentSensor = sensor.sensor_ns.INA219CurrentSensor INA219PowerSensor = sensor.sensor_ns.INA219PowerSensor PLATFORM_SCHEMA = vol.All( sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(INA219Component), vol.Optional(CONF_ADDRESS, default=0x40): cv.i2c_address, vol.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA), vol.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA), vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA), vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA), 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):