Initial Commit 🎉

esphomeyaml/components/ads1115.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_RATE
+from esphomeyaml.helpers import App, Pvariable, RawExpression, add, HexIntLiteral
+
+DEPENDENCIES = ['i2c']
+
+ADS1115_COMPONENT_CLASS = 'sensor::ADS1115Component'
+
+RATES = {
+    8: 'ADS1115_RATE_8',
+    16: 'ADS1115_RATE_16',
+    32: 'ADS1115_RATE_32',
+    64: 'ADS1115_RATE_64',
+    128: 'ADS1115_RATE_128',
+    250: 'ADS1115_RATE_250',
+    475: 'ADS1115_RATE_475',
+    860: 'ADS1115_RATE_860',
+}
+
+ADS1115_SCHEMA = vol.Schema({
+    cv.GenerateID('ads1115'): cv.register_variable_id,
+    vol.Required(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_RATE): vol.All(vol.Coerce(int), vol.Any(*list(RATES.keys()))),
+})
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [ADS1115_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        address = HexIntLiteral(conf[CONF_ADDRESS])
+        rhs = App.make_ads1115_component(address)
+        ads1115 = Pvariable(ADS1115_COMPONENT_CLASS, conf[CONF_ID], rhs)
+        if CONF_RATE in conf:
+            add(ads1115.set_rate(RawExpression(RATES[conf[CONF_RATE]])))

esphomeyaml/components/binary_sensor/__init__.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_INVERTED
+from esphomeyaml.helpers import add, setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_INVERTED): cv.boolean,
+})
+
+DEVICE_CLASSES = [
+    '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
+    'heat', 'light', 'lock', 'moisture', 'motion', 'moving', 'occupancy',
+    'opening', 'plug', 'power', 'presence', 'problem', 'safety', 'smoke',
+    'sound', 'vibration', 'window'
+]
+
+DEVICE_CLASSES_MSG = "Unknown device class. Must be one of {}".format(', '.join(DEVICE_CLASSES))
+
+MQTT_BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    vol.Optional(CONF_DEVICE_CLASS): vol.All(vol.Lower,
+                                             vol.Any(*DEVICE_CLASSES, msg=DEVICE_CLASSES_MSG)),
+})
+
+
+def setup_mqtt_binary_sensor(obj, config, skip_device_class=False):
+    if not skip_device_class and CONF_DEVICE_CLASS in config:
+        add(obj.set_device_class(config[CONF_DEVICE_CLASS]))
+    setup_mqtt_component(obj, config)

esphomeyaml/components/binary_sensor/gpio.py

@@ -0,0 +1,21 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_ID, CONF_INVERTED, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, add, exp_gpio_input_pin, variable
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('gpio_binary_sensor'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.GPIO_INPUT_PIN_SCHEMA
+}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_gpio_binary_sensor(exp_gpio_input_pin(config[CONF_PIN]),
+                                      config[CONF_NAME], config.get(CONF_DEVICE_CLASS))
+    gpio = variable('Application::SimpleBinarySensor', config[CONF_ID], rhs)
+    if CONF_INVERTED in config:
+        add(gpio.Pgpio.set_inverted(config[CONF_INVERTED]))
+    binary_sensor.setup_mqtt_binary_sensor(gpio.Pmqtt, config, skip_device_class=True)

esphomeyaml/components/binary_sensor/status.py

@@ -0,0 +1,14 @@
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_ID, CONF_NAME
+from esphomeyaml.helpers import App, Pvariable
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('status_binary_sensor'): cv.register_variable_id,
+}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_status_binary_sensor(config[CONF_NAME])
+    gpio = Pvariable('binary_sensor::MQTTBinarySensorComponent', config[CONF_ID], rhs)
+    binary_sensor.setup_mqtt_binary_sensor(gpio.Pmqtt, config)

esphomeyaml/components/dallas.py

@@ -0,0 +1,20 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Pvariable
+
+DALLAS_COMPONENT_CLASS = 'sensor::DallasComponent'
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
+    cv.GenerateID('dallas'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.input_output_pin,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})])
+
+
+def to_code(config):
+    for conf in config:
+        rhs = App.make_dallas_component(conf[CONF_PIN], conf.get(CONF_UPDATE_INTERVAL))
+        Pvariable(DALLAS_COMPONENT_CLASS, conf[CONF_ID], rhs)

esphomeyaml/components/fan/__init__.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_OSCILLATION_COMMAND_TOPIC, CONF_OSCILLATION_STATE_TOPIC, \
+    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphomeyaml.helpers import add, setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_OSCILLATION_STATE_TOPIC): cv.publish_topic,
+    vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): cv.subscribe_topic,
+}).extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA.schema)
+
+
+def setup_mqtt_fan(obj, config):
+    if CONF_OSCILLATION_STATE_TOPIC in config:
+        add(obj.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
+    if CONF_OSCILLATION_COMMAND_TOPIC in config:
+        add(obj.set_custom_oscillation_command_topic(config[CONF_OSCILLATION_COMMAND_TOPIC]))
+    if CONF_SPEED_STATE_TOPIC in config:
+        add(obj.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
+    if CONF_SPEED_COMMAND_TOPIC in config:
+        add(obj.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
+    setup_mqtt_component(obj, config)

esphomeyaml/components/fan/binary.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import fan
+from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
+from esphomeyaml.helpers import App, add, get_variable, variable
+
+PLATFORM_SCHEMA = fan.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('binary_fan'): cv.register_variable_id,
+    vol.Required(CONF_OUTPUT): cv.variable_id,
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.variable_id,
+})
+
+
+def to_code(config):
+    output = get_variable(config[CONF_OUTPUT])
+    rhs = App.make_fan(config[CONF_NAME])
+    fan_struct = variable('Application::FanStruct', config[CONF_ID], rhs)
+    add(fan_struct.Poutput.set_binary(output))
+    if CONF_OSCILLATION_OUTPUT in config:
+        oscillation_output = get_variable(config[CONF_OSCILLATION_OUTPUT])
+        add(fan_struct.Poutput.set_oscillation(oscillation_output))
+    fan.setup_mqtt_fan(fan_struct.Pmqtt, config)

esphomeyaml/components/fan/speed.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import fan
+from esphomeyaml.const import CONF_HIGH, CONF_ID, CONF_LOW, \
+    CONF_MEDIUM, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_SPEED, \
+    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphomeyaml.helpers import App, add, get_variable, variable
+
+PLATFORM_SCHEMA = fan.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('speed_fan'): cv.register_variable_id,
+    vol.Required(CONF_OUTPUT): cv.variable_id,
+    vol.Optional(CONF_SPEED_STATE_TOPIC): cv.publish_topic,
+    vol.Optional(CONF_SPEED_COMMAND_TOPIC): cv.subscribe_topic,
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.variable_id,
+    vol.Optional(CONF_SPEED): vol.Schema({
+        vol.Required(CONF_LOW): cv.zero_to_one_float,
+        vol.Required(CONF_MEDIUM): cv.zero_to_one_float,
+        vol.Required(CONF_HIGH): cv.zero_to_one_float,
+    }),
+})
+
+
+def to_code(config):
+    output = get_variable(config[CONF_OUTPUT])
+    rhs = App.make_fan(config[CONF_NAME])
+    fan_struct = variable('Application::FanStruct', config[CONF_ID], rhs)
+    if CONF_SPEED in config:
+        speeds = config[CONF_SPEED]
+        add(fan_struct.Poutput.set_speed(output, 0.0,
+                                         speeds[CONF_LOW],
+                                         speeds[CONF_MEDIUM],
+                                         speeds[CONF_HIGH]))
+    else:
+        add(fan_struct.Poutput.set_speed(output))
+
+    if CONF_OSCILLATION_OUTPUT in config:
+        oscillation_output = get_variable(config[CONF_OSCILLATION_OUTPUT])
+        add(fan_struct.Poutput.set_oscillation(oscillation_output))
+    fan.setup_mqtt_fan(fan_struct.Pmqtt, config)

esphomeyaml/components/i2c.py

@@ -0,0 +1,16 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_FREQUENCY, CONF_SCL, CONF_SDA
+from esphomeyaml.helpers import App, add
+
+CONFIG_SCHEMA = vol.Schema({
+    vol.Required(CONF_SDA, default='SDA'): pins.input_output_pin,
+    vol.Required(CONF_SCL, default='SCL'): pins.input_output_pin,
+    vol.Optional(CONF_FREQUENCY): vol.All(cv.only_on_esp32, cv.positive_int),
+})
+
+
+def to_code(config):
+    add(App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_FREQUENCY)))

esphomeyaml/components/ir_transmitter.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+IR_TRANSMITTER_COMPONENT_CLASS = 'switch_::IRTransmitterComponent'
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
+    cv.GenerateID('ir_transmitter'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Optional(CONF_CARRIER_DUTY_PERCENT): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),
+})])
+
+
+def to_code(config):
+    for conf in config:
+        pin = exp_gpio_output_pin(conf[CONF_PIN])
+        rhs = App.make_ir_transmitter(pin, conf.get(CONF_CARRIER_DUTY_PERCENT))
+        Pvariable(IR_TRANSMITTER_COMPONENT_CLASS, conf[CONF_ID], rhs)

esphomeyaml/components/light/__init__.py

@@ -0,0 +1,13 @@
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH
+from esphomeyaml.helpers import add, setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+}).extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA.schema)
+
+
+def setup_mqtt_light_component(obj, config):
+    if CONF_DEFAULT_TRANSITION_LENGTH in config:
+        add(obj.set_default_transition_length(config[CONF_DEFAULT_TRANSITION_LENGTH]))
+    setup_mqtt_component(obj, config)

esphomeyaml/components/light/binary.py

@@ -0,0 +1,19 @@
+
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_OUTPUT
+from esphomeyaml.helpers import App, get_variable, variable
+
+PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('binary_light'): cv.register_variable_id,
+    vol.Required(CONF_OUTPUT): cv.variable_id,
+})
+
+
+def to_code(config):
+    output = get_variable(config[CONF_OUTPUT])
+    rhs = App.make_binary_light(config[CONF_NAME], output)
+    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
+    light.setup_mqtt_light_component(light_struct.Pmqtt, config)

esphomeyaml/components/light/monochromatic.py

@@ -0,0 +1,23 @@
+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_ID, \
+    CONF_NAME, CONF_OUTPUT
+from esphomeyaml.helpers import App, add, get_variable, variable
+
+PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('monochromatic_light'): cv.register_variable_id,
+    vol.Required(CONF_OUTPUT): cv.variable_id,
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period,
+})
+
+
+def to_code(config):
+    output = get_variable(config[CONF_OUTPUT])
+    rhs = App.make_monochromatic_light(config[CONF_NAME], output)
+    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
+    if CONF_GAMMA_CORRECT in config:
+        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
+    light.setup_mqtt_light_component(light_struct.Pmqtt, config)

esphomeyaml/components/light/rgb.py

@@ -0,0 +1,27 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
+    CONF_GREEN, CONF_ID, CONF_NAME, CONF_RED
+from esphomeyaml.helpers import App, add, get_variable, variable
+
+PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('rgb_light'): cv.register_variable_id,
+    vol.Required(CONF_RED): cv.variable_id,
+    vol.Required(CONF_GREEN): cv.variable_id,
+    vol.Required(CONF_BLUE): cv.variable_id,
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period,
+})
+
+
+def to_code(config):
+    red = get_variable(config[CONF_RED])
+    green = get_variable(config[CONF_GREEN])
+    blue = get_variable(config[CONF_BLUE])
+    rhs = App.make_rgb_light(config[CONF_NAME], red, green, blue)
+    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
+    if CONF_GAMMA_CORRECT in config:
+        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
+    light.setup_mqtt_light_component(light_struct.Pmqtt, config)

esphomeyaml/components/light/rgbw.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
+    CONF_GREEN, CONF_ID, CONF_NAME, CONF_RED, CONF_WHITE
+from esphomeyaml.helpers import App, get_variable, variable, add
+
+PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('rgbw_light'): cv.register_variable_id,
+    vol.Required(CONF_RED): cv.variable_id,
+    vol.Required(CONF_GREEN): cv.variable_id,
+    vol.Required(CONF_BLUE): cv.variable_id,
+    vol.Required(CONF_WHITE): cv.variable_id,
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period,
+})
+
+
+def to_code(config):
+    red = get_variable(config[CONF_RED])
+    green = get_variable(config[CONF_GREEN])
+    blue = get_variable(config[CONF_BLUE])
+    white = get_variable(config[CONF_WHITE])
+    rhs = App.make_rgbw_light(config[CONF_NAME], red, green, blue, white)
+    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
+    if CONF_GAMMA_CORRECT in config:
+        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
+    light.setup_mqtt_light_component(light_struct.Pmqtt, config)

esphomeyaml/components/logger.py

@@ -0,0 +1,60 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_BAUD_RATE, CONF_ID, CONF_LEVEL, CONF_LOGGER, CONF_LOGS, \
+    CONF_LOG_TOPIC, CONF_TX_BUFFER_SIZE
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, Pvariable, RawExpression, add, exp_empty_optional
+
+LOG_LEVELS = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE']
+
+is_log_level = vol.All(vol.Upper, vol.Any(*LOG_LEVELS))
+
+CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+    cv.GenerateID(CONF_LOGGER): cv.register_variable_id,
+    vol.Optional(CONF_BAUD_RATE): cv.positive_int,
+    vol.Optional(CONF_LOG_TOPIC): vol.Any(None, '', cv.publish_topic),
+    vol.Optional(CONF_TX_BUFFER_SIZE): cv.positive_int,
+    vol.Optional(CONF_LEVEL): is_log_level,
+    vol.Optional(CONF_LOGS): vol.Schema({
+        cv.string: is_log_level,
+    })
+})
+
+
+def esphomelib_log_level(level):
+    return u'ESPHOMELIB_LOG_LEVEL_{}'.format(level)
+
+
+def exp_log_level(level):
+    return RawExpression(esphomelib_log_level(level))
+
+
+def to_code(config):
+    baud_rate = config.get(CONF_BAUD_RATE)
+    if baud_rate is None and CONF_LOG_TOPIC in config:
+        baud_rate = 115200
+    log_topic = None
+    if CONF_LOG_TOPIC in config:
+        if not config[CONF_LOG_TOPIC]:
+            log_topic = exp_empty_optional(u'std::string')
+        else:
+            log_topic = config[CONF_LOG_TOPIC]
+    rhs = App.init_log(baud_rate, log_topic)
+    log = Pvariable(u'LogComponent', config[CONF_ID], rhs)
+    if CONF_TX_BUFFER_SIZE in config:
+        add(log.set_tx_buffer_size(config[CONF_TX_BUFFER_SIZE]))
+    if CONF_LEVEL in config:
+        add(log.set_global_log_level(exp_log_level(config[CONF_LEVEL])))
+    for tag, level in config.get(CONF_LOGS, {}).iteritems():
+        global_level = config.get(CONF_LEVEL, 'DEBUG')
+        if LOG_LEVELS.index(level) > LOG_LEVELS.index(global_level):
+            raise ESPHomeYAMLError(u"The local log level {} for {} must be less severe than the "
+                                   u"global log level {}.".format(level, tag, global_level))
+        add(log.set_log_level(tag, exp_log_level(level)))
+
+
+def get_build_flags(config):
+    if CONF_LEVEL in config:
+        return u'-DESPHOMELIB_LOG_LEVEL={}'.format(esphomelib_log_level(config[CONF_LEVEL]))
+    return u''

esphomeyaml/components/mqtt.py

@@ -0,0 +1,74 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_DISCOVERY, \
+    CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, CONF_ID, CONF_MQTT, CONF_PASSWORD, \
+    CONF_PAYLOAD, CONF_PORT, CONF_QOS, CONF_RETAIN, CONF_TOPIC, CONF_TOPIC_PREFIX, CONF_USERNAME, \
+    CONF_WILL_MESSAGE, CONF_CLIENT_ID
+from esphomeyaml.helpers import App, Pvariable, StructInitializer, add, exp_empty_optional
+
+MQTT_WILL_BIRTH_SCHEMA = vol.Any(None, vol.Schema({
+    vol.Required(CONF_TOPIC): cv.publish_topic,
+    vol.Required(CONF_PAYLOAD): cv.mqtt_payload,
+    vol.Optional(CONF_QOS, default=0): vol.All(vol.Coerce(int), vol.In([0, 1, 2])),
+    vol.Optional(CONF_RETAIN, default=True): cv.boolean,
+}))
+
+
+def validate_broker(value):
+    value = cv.string_strict(value)
+    if value.endswith(u'.local'):
+        raise vol.Invalid(u"MQTT server addresses ending with '.local' are currently unsupported."
+                          u" Please specify the static IP instead.")
+    if u':' in value:
+        raise vol.Invalid(u"Please specify the port using the port: option")
+    return value
+
+
+CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT): cv.register_variable_id,
+    vol.Required(CONF_BROKER): validate_broker,
+    vol.Optional(CONF_PORT, default=1883): cv.port,
+    vol.Optional(CONF_USERNAME, default=''): cv.string,
+    vol.Optional(CONF_PASSWORD, default=''): cv.string,
+    vol.Optional(CONF_CLIENT_ID): vol.All(cv.string, vol.Length(max=23)),
+    vol.Optional(CONF_DISCOVERY): cv.boolean,
+    vol.Optional(CONF_DISCOVERY_RETAIN): cv.boolean,
+    vol.Optional(CONF_DISCOVERY_PREFIX): cv.publish_topic,
+    vol.Optional(CONF_BIRTH_MESSAGE): MQTT_WILL_BIRTH_SCHEMA,
+    vol.Optional(CONF_WILL_MESSAGE): MQTT_WILL_BIRTH_SCHEMA,
+    vol.Optional(CONF_TOPIC_PREFIX): cv.publish_topic,
+})
+
+
+def exp_mqtt_message(config):
+    if config is None:
+        return exp_empty_optional('mqtt::MQTTMessage')
+    exp = StructInitializer(
+        'mqtt::MQTTMessage',
+        ('topic', config[CONF_TOPIC]),
+        ('payload', config[CONF_PAYLOAD]),
+        ('qos', config[CONF_QOS]),
+        ('retain', config[CONF_RETAIN])
+    )
+    return exp
+
+
+def to_code(config):
+    rhs = App.init_mqtt(config[CONF_BROKER], config[CONF_PORT],
+                        config[CONF_USERNAME], config[CONF_PASSWORD])
+    mqtt = Pvariable('mqtt::MQTTClientComponent', config[CONF_ID], rhs)
+    if not config.get(CONF_DISCOVERY, True):
+        add(mqtt.disable_discovery())
+    if CONF_DISCOVERY_RETAIN in config or CONF_DISCOVERY_PREFIX in config:
+        discovery_retain = config.get(CONF_DISCOVERY_RETAIN, True)
+        discovery_prefix = config.get(CONF_DISCOVERY_PREFIX, 'homeassistant')
+        add(mqtt.set_discovery_info(discovery_prefix, discovery_retain))
+    if CONF_BIRTH_MESSAGE in config:
+        add(mqtt.set_birth_message(config[CONF_BIRTH_MESSAGE]))
+    if CONF_WILL_MESSAGE in config:
+        add(mqtt.set_last_will(config[CONF_WILL_MESSAGE]))
+    if CONF_TOPIC_PREFIX in config:
+        add(mqtt.set_topic_prefix(config[CONF_TOPIC_PREFIX]))
+    if CONF_CLIENT_ID in config:
+        add(mqtt.set_client_id(config[CONF_CLIENT_ID]))

esphomeyaml/components/ota.py

@@ -0,0 +1,44 @@
+import hashlib
+import logging
+
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_OTA, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE, \
+    ESP_PLATFORM_ESP8266, ESP_PLATFORM_ESP32
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, Pvariable, add
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+    cv.GenerateID(CONF_OTA): cv.register_variable_id,
+    vol.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
+    # TODO Num attempts + wait time
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Optional(CONF_PASSWORD): cv.string,
+})
+
+
+def to_code(config):
+    rhs = App.init_ota()
+    ota = Pvariable('OTAComponent', config[CONF_ID], rhs)
+    if CONF_PASSWORD in config:
+        h = hashlib.md5(config[CONF_PASSWORD].encode()).hexdigest()
+        add(ota.set_auth_password_hash(h))
+    if config[CONF_SAFE_MODE]:
+        add(ota.start_safe_mode())
+
+
+def get_port(config):
+    if CONF_PORT in config[CONF_OTA]:
+        return config[CONF_OTA][CONF_PORT]
+    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return 3232
+    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+        return 8266
+    raise ESPHomeYAMLError(u"Invalid ESP Platform for ESP OTA port.")
+
+
+def get_auth(config):
+    return config[CONF_OTA].get(CONF_PASSWORD, '')

esphomeyaml/components/output/__init__.py

@@ -0,0 +1,25 @@
+
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_POWER_SUPPLY, CONF_INVERTED, CONF_MAX_POWER
+from esphomeyaml.helpers import get_variable, add
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_POWER_SUPPLY): cv.variable_id,
+    vol.Optional(CONF_INVERTED): cv.boolean,
+}).extend(cv.REQUIRED_ID_SCHEMA.schema)
+
+FLOAT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_MAX_POWER): cv.zero_to_one_float,
+})
+
+
+def setup_output_platform(obj, config, skip_power_supply=False):
+    if CONF_INVERTED in config:
+        add(obj.set_inverted(config[CONF_INVERTED]))
+    if not skip_power_supply and CONF_POWER_SUPPLY in config:
+        power_supply = get_variable(config[CONF_POWER_SUPPLY])
+        add(obj.set_power_supply(power_supply))
+    if CONF_MAX_POWER in config:
+        add(obj.set_max_power(config[CONF_MAX_POWER]))

esphomeyaml/components/output/esp8266_pwm.py

@@ -0,0 +1,24 @@
+import voluptuous as vol
+
+from esphomeyaml import pins
+from esphomeyaml.components import output
+from esphomeyaml.const import CONF_ID, CONF_PIN, \
+    ESP_PLATFORM_ESP8266
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin, get_gpio_pin_number
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
+
+PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+})
+
+
+def to_code(config):
+    if get_gpio_pin_number(config[CONF_PIN]) >= 16:
+        # Too difficult to do in config validation
+        raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
+    pin = exp_gpio_output_pin(config[CONF_PIN])
+    rhs = App.make_esp8266_pwm_output(pin)
+    gpio = Pvariable('output::ESP8266PWMOutput', config[CONF_ID], rhs)
+    output.setup_output_platform(gpio, config)

esphomeyaml/components/output/gpio.py

@@ -0,0 +1,17 @@
+import voluptuous as vol
+
+from esphomeyaml import pins
+from esphomeyaml.components import output
+from esphomeyaml.const import CONF_ID, CONF_PIN
+from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
+
+PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+})
+
+
+def to_code(config):
+    pin = exp_gpio_output_pin(config[CONF_PIN])
+    rhs = App.make_gpio_output(pin)
+    gpio = Pvariable('output::GPIOBinaryOutputComponent', config[CONF_ID], rhs)
+    output.setup_output_platform(gpio, config)

esphomeyaml/components/output/ledc.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import output
+from esphomeyaml.const import APB_CLOCK_FREQ, CONF_BIT_DEPTH, CONF_CHANNEL, CONF_FREQUENCY, \
+    CONF_ID, CONF_PIN, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, Pvariable, add
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+
+def validate_frequency_bit_depth(obj):
+    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 {}'.format(bit_depth, max_freq))
+    return obj
+
+
+PLATFORM_SCHEMA = vol.All(output.FLOAT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PIN): vol.All(pins.output_pin, vol.Range(min=0, max=33)),
+    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))
+}), 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
+    rhs = App.make_ledc_output(config[CONF_PIN], frequency, config.get(CONF_BIT_DEPTH))
+    ledc = Pvariable('output::LEDCOutputComponent', config[CONF_ID], rhs)
+    if CONF_CHANNEL in config:
+        add(ledc.set_channel(config[CONF_CHANNEL]))
+    output.setup_output_platform(ledc, config)

esphomeyaml/components/output/pca9685.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import output
+from esphomeyaml.components.pca9685 import PCA9685_COMPONENT_TYPE
+from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY
+from esphomeyaml.helpers import Pvariable, get_variable
+
+DEPENDENCIES = ['pca9685']
+
+PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_CHANNEL): vol.All(vol.Coerce(int),
+                                        vol.Range(min=0, max=15)),
+    vol.Optional(CONF_PCA9685_ID): cv.variable_id,
+})
+
+
+def to_code(config):
+    power_supply = None
+    if CONF_POWER_SUPPLY in config:
+        power_supply = get_variable(config[CONF_POWER_SUPPLY])
+    pca9685 = get_variable(config.get(CONF_PCA9685_ID), PCA9685_COMPONENT_TYPE)
+    rhs = pca9685.create_channel(config[CONF_CHANNEL], power_supply)
+    out = Pvariable('output::PCA9685OutputComponent::Channel', config[CONF_ID], rhs)
+    output.setup_output_platform(out, config, skip_power_supply=True)

esphomeyaml/components/pca9685.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_FREQUENCY, CONF_ID, CONF_PHASE_BALANCER
+from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, RawExpression, add
+
+DEPENDENCIES = ['i2c']
+
+PHASE_BALANCERS = ['None', 'Linear', 'Weaved']
+
+PCA9685_COMPONENT_TYPE = 'output::PCA9685OutputComponent'
+
+PCA9685_SCHEMA = vol.Schema({
+    cv.GenerateID('pca9685'): cv.register_variable_id,
+    vol.Required(CONF_FREQUENCY): vol.All(cv.frequency,
+                                          vol.Range(min=24, max=1526)),
+    vol.Optional(CONF_PHASE_BALANCER): vol.All(vol.Title, vol.Any(*PHASE_BALANCERS)),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+})
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCA9685_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        rhs = App.make_pca9685_component(conf.get(CONF_FREQUENCY))
+        pca9685 = Pvariable(PCA9685_COMPONENT_TYPE, conf[CONF_ID], rhs)
+        if CONF_ADDRESS in conf:
+            add(pca9685.set_address(HexIntLiteral(conf[CONF_ADDRESS])))
+        if CONF_PHASE_BALANCER in conf:
+            phase_balancer = RawExpression(u'PCA9685_PhaseBalancer_{}'.format(
+                conf[CONF_PHASE_BALANCER]))
+            add(pca9685.set_phase_balancer(phase_balancer))

esphomeyaml/components/power_supply.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
+from esphomeyaml.helpers import App, Pvariable, add, exp_gpio_output_pin
+
+POWER_SUPPLY_SCHEMA = cv.REQUIRED_ID_SCHEMA.extend({
+    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period,
+    vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period,
+})
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [POWER_SUPPLY_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        pin = exp_gpio_output_pin(conf[CONF_PIN])
+        rhs = App.make_power_supply(pin)
+        psu = Pvariable('PowerSupplyComponent', conf[CONF_ID], rhs)
+        if CONF_ENABLE_TIME in conf:
+            add(psu.set_enable_time(conf[CONF_ENABLE_TIME]))
+        if CONF_KEEP_ON_TIME in conf:
+            add(psu.set_keep_on_time(conf[CONF_KEEP_ON_TIME]))

esphomeyaml/components/sensor/__init__.py

@@ -0,0 +1,100 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_EXPIRE_AFTER, \
+    CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_ICON, \
+    CONF_ID, CONF_LAMBDA, CONF_MULTIPLY, CONF_NAME, CONF_OFFSET, CONF_SEND_EVERY, \
+    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
+from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
+    setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.Any(
+    # TODO Fix weird voluptuous error messages
+    vol.Schema({vol.Required(CONF_OFFSET): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_MULTIPLY): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_FILTER_OUT): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_FILTER_NAN): None}),
+    vol.Schema({
+        vol.Required(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.Schema({
+            vol.Required(CONF_WINDOW_SIZE): cv.positive_not_null_int,
+            vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+        })
+    }),
+    vol.Schema({
+        vol.Required(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
+            vol.Required(CONF_ALPHA): cv.positive_float,
+            vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+        })
+    }),
+    vol.Schema({vol.Required(CONF_LAMBDA): cv.string_strict}),
+)])
+
+MQTT_SENSOR_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.string,
+    vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string_strict,
+    vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_ACCURACY_DECIMALS): vol.Coerce(int),
+    vol.Optional(CONF_EXPIRE_AFTER): vol.Any(None, cv.positive_time_period),
+    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA
+})
+
+MQTT_SENSOR_ID_SCHEMA = MQTT_SENSOR_SCHEMA.extend({
+    cv.GenerateID('mqtt_sensor'): cv.register_variable_id,
+})
+
+OffsetFilter = MockObj('new sensor::OffsetFilter')
+MultiplyFilter = MockObj('new sensor::MultiplyFilter')
+FilterOutValueFilter = MockObj('new sensor::FilterOutValueFilter')
+FilterOutNANFilter = MockObj('new sensor::FilterOutNANFilter')
+SlidingWindowMovingAverageFilter = MockObj('new sensor::SlidingWindowMovingAverageFilter')
+ExponentialMovingAverageFilter = MockObj('new sensor::ExponentialMovingAverageFilter')
+LambdaFilter = MockObj('new sensor::LambdaFilter')
+
+
+def setup_filter(config):
+    if CONF_OFFSET in config:
+        return OffsetFilter(config[CONF_OFFSET])
+    if CONF_MULTIPLY in config:
+        return MultiplyFilter(config[CONF_MULTIPLY])
+    if CONF_FILTER_OUT in config:
+        return FilterOutValueFilter(config[CONF_FILTER_OUT])
+    if CONF_FILTER_NAN in config:
+        return FilterOutNANFilter()
+    if CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
+        conf = config[CONF_SLIDING_WINDOW_MOVING_AVERAGE]
+        return SlidingWindowMovingAverageFilter(conf[CONF_WINDOW_SIZE], conf[CONF_SEND_EVERY])
+    if CONF_EXPONENTIAL_MOVING_AVERAGE in config:
+        conf = config[CONF_EXPONENTIAL_MOVING_AVERAGE]
+        return ExponentialMovingAverageFilter(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
+    if CONF_LAMBDA in config:
+        s = '[](float x) -> Optional<float> {{ return {}; }}'.format(config[CONF_LAMBDA])
+        return LambdaFilter(RawExpression(s))
+    raise ValueError("Filter unsupported: {}".format(config))
+
+
+def setup_mqtt_sensor_component(obj, config):
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        add(obj.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+    if CONF_ICON in config:
+        add(obj.set_icon(config[CONF_ICON]))
+    if CONF_ACCURACY_DECIMALS in config:
+        add(obj.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_EXPIRE_AFTER in config:
+        if config[CONF_EXPIRE_AFTER] is None:
+            add(obj.disable_expire_after())
+        else:
+            add(obj.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    if CONF_FILTERS in config:
+        filters = [setup_filter(x) for x in config[CONF_FILTERS]]
+        add(obj.set_filters(ArrayInitializer(*filters)))
+    setup_mqtt_component(obj, config)
+
+
+def make_mqtt_sensor_for(exp, config):
+    rhs = App.make_mqtt_sensor_for(exp, config[CONF_NAME])
+    mqtt_sensor = Pvariable('sensor::MQTTSensorComponent', config[CONF_ID], rhs)
+    setup_mqtt_sensor_component(mqtt_sensor, config)

esphomeyaml/components/sensor/adc.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, RawExpression, add, variable
+
+ATTENUATION_MODES = {
+    '0db': 'ADC_0db',
+    '2.5db': 'ADC_2_5db',
+    '6db': 'ADC_6db',
+    '11db': 'ADC_11db',
+}
+
+ATTENUATION_MODE_SCHEMA = vol.Any(*list(ATTENUATION_MODES.keys()))
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('adc'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.analog_pin,
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, ATTENUATION_MODE_SCHEMA),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_adc_sensor(config[CONF_PIN], config[CONF_NAME],
+                              config.get(CONF_UPDATE_INTERVAL))
+    make = variable('Application::MakeADCSensor', config[CONF_ID], rhs)
+    adc = make.Padc
+    if CONF_ATTENUATION in config:
+        attenuation = ATTENUATION_MODES[config[CONF_ATTENUATION]]
+        add(adc.set_attenuation(RawExpression(attenuation)))
+    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)

esphomeyaml/components/sensor/ads1115.py

@@ -0,0 +1,56 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import get_variable, RawExpression
+
+DEPENDENCIES = ['ads1115']
+
+MUX = {
+    'A0_A1': 'ADS1115_MUX_P0_N1',
+    'A0_A3': 'ADS1115_MUX_P0_N3',
+    'A1_A3': 'ADS1115_MUX_P1_N3',
+    'A2_A3': 'ADS1115_MUX_P2_N3',
+    'A0_GND': 'ADS1115_MUX_P0_NG',
+    'A1_GND': 'ADS1115_MUX_P1_NG',
+    'A2_GND': 'ADS1115_MUX_P2_NG',
+    'A3_GND': 'ADS1115_MUX_P3_NG',
+}
+
+GAIN = {
+    '6.144': 'ADS1115_PGA_6P144',
+    '4.096': 'ADS1115_PGA_6P096',
+    '2.048': 'ADS1115_PGA_2P048',
+    '1.024': 'ADS1115_PGA_1P024',
+    '0.512': 'ADS1115_PGA_0P512',
+    '0.256': 'ADS1115_PGA_0P256',
+}
+
+
+def validate_gain(value):
+    if isinstance(value, float):
+        value = u'{:0.03f}'.format(value)
+    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid('invalid gain "{}"'.format(value))
+
+    if value not in GAIN:
+        raise vol.Invalid("Invalid gain, options are {}".format(', '.join(GAIN.keys())))
+    return value
+
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_MULTIPLEXER): vol.All(vol.Upper, vol.Any(*list(MUX.keys()))),
+    vol.Required(CONF_GAIN): validate_gain,
+    vol.Optional(CONF_ADS1115_ID): cv.variable_id,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_ID_SCHEMA.schema)
+
+
+def to_code(config):
+    hub = get_variable(config.get(CONF_ADS1115_ID), u'sensor::ADS1115Component')
+
+    mux = RawExpression(MUX[config[CONF_MULTIPLEXER]])
+    gain = RawExpression(GAIN[config[CONF_GAIN]])
+    sensor_ = hub.get_sensor(mux, gain, config.get(CONF_UPDATE_INTERVAL))
+    sensor.make_mqtt_sensor_for(sensor_, config)

esphomeyaml/components/sensor/bmp085.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, \
+    CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, HexIntLiteral, add, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('bmp085_sensor'): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_PRESSURE): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+def to_code(config):
+    rhs = App.make_bmp085_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bmp = variable('Application::MakeBMP085Component', config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(bmp.Pbmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
+    sensor.setup_mqtt_sensor_component(bmp.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(bmp.Pmqtt_pressure, config[CONF_PRESSURE])

esphomeyaml/components/sensor/dallas.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.dallas import DALLAS_COMPONENT_CLASS
+from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import HexIntLiteral, get_variable
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    vol.Exclusive(CONF_ADDRESS, 'dallas'): cv.hex_int,
+    vol.Exclusive(CONF_INDEX, 'dallas'): cv.positive_int,
+    vol.Optional(CONF_DALLAS_ID): cv.variable_id,
+    vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=8, max=12)),
+}).extend(sensor.MQTT_SENSOR_ID_SCHEMA.schema)
+
+
+def to_code(config):
+    hub = get_variable(config.get(CONF_DALLAS_ID), DALLAS_COMPONENT_CLASS)
+    update_interval = config.get(CONF_UPDATE_INTERVAL)
+    if CONF_RESOLUTION in config and update_interval is None:
+        update_interval = 10000
+
+    if CONF_ADDRESS in config:
+        address = HexIntLiteral(config[CONF_ADDRESS])
+        sensor_ = hub.Pget_sensor_by_address(address, update_interval,
+                                             config.get(CONF_RESOLUTION))
+    else:
+        sensor_ = hub.Pget_sensor_by_index(config[CONF_INDEX], update_interval,
+                                           config.get(CONF_RESOLUTION))
+    sensor.make_mqtt_sensor_for(sensor_, config)

esphomeyaml/components/sensor/dht.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, RawExpression, add, variable
+
+DHT_MODELS = ['AUTO_DETECT', 'DHT11', 'DHT22', 'AM2302', 'RHT03']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('dht_sensor'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.input_output_pin,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_MODEL): vol.All(vol.Upper, vol.Any(*DHT_MODELS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+def to_code(config):
+    rhs = App.make_dht_sensor(config[CONF_PIN], config[CONF_TEMPERATURE][CONF_NAME],
+                              config[CONF_HUMIDITY][CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    dht = variable('Application::MakeDHTComponent', config[CONF_ID], rhs)
+    if CONF_MODEL in config:
+        model = RawExpression('DHT::{}'.format(config[CONF_MODEL]))
+        add(dht.Pdht.set_dht_model(model))
+    sensor.setup_mqtt_sensor_component(dht.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(dht.Pmqtt_humidity, config[CONF_HUMIDITY])

esphomeyaml/components/sensor/hdc1080.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('dht_sensor'): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+def to_code(config):
+    rhs = App.make_hdc1080_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                  config[CONF_HUMIDITY][CONF_NAME],
+                                  config.get(CONF_UPDATE_INTERVAL))
+    hdc1080 = variable('Application::MakeHDC1080Component', config[CONF_ID], rhs)
+    sensor.setup_mqtt_sensor_component(hdc1080.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(hdc1080.Pmqtt_humidity, config[CONF_HUMIDITY])

esphomeyaml/components/sensor/htu21d.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('htu21d'): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+def to_code(config):
+    rhs = App.make_htu21d_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    htu21d = variable('Application::MakeHTU21DComponent', config[CONF_ID], rhs)
+    sensor.setup_mqtt_sensor_component(htu21d.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(htu21d.Pmqtt_humidity, config[CONF_HUMIDITY])

esphomeyaml/components/sensor/pulse_counter.py

@@ -0,0 +1,58 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
+    CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
+    ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, RawExpression, add, variable
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+GPIO_PULL_MODES = {
+    'PULLUP': 'GPIO_PULLUP_ONLY',
+    'PULLDOWN': 'GPIO_PULLDOWN_ONLY',
+    'PULLUP_PULLDOWN': 'GPIO_PULLUP_PULLDOWN',
+    'FLOATING': 'GPIO_FLOATING',
+}
+
+GPIO_PULL_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(GPIO_PULL_MODES.keys())))
+
+COUNT_MODES = {
+    'DISABLE': 'PCNT_COUNT_DIS',
+    'INCREMENT': 'PCNT_COUNT_INC',
+    'DECREMENT': 'PCNT_COUNT_DEC',
+}
+
+COUNT_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(COUNT_MODES.keys())))
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('pulse_counter'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.input_pin,
+    vol.Optional(CONF_PULL_MODE): GPIO_PULL_MODE_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): vol.All(vol.Coerce(int), vol.Range(min=0, max=1023)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_pulse_counter_sensor(config[CONF_PIN], config[CONF_NAME],
+                                        config.get(CONF_UPDATE_INTERVAL))
+    make = variable('Application::MakePulseCounter', config[CONF_ID], rhs)
+    pcnt = make.Ppcnt
+    if CONF_PULL_MODE in config:
+        pull_mode = GPIO_PULL_MODES[config[CONF_PULL_MODE]]
+        add(pcnt.set_pull_mode(RawExpression(pull_mode)))
+    if CONF_COUNT_MODE in config:
+        count_mode = config[CONF_COUNT_MODE]
+        rising_edge = COUNT_MODES[count_mode[CONF_RISING_EDGE]]
+        falling_edge = COUNT_MODES[count_mode[CONF_FALLING_EDGE]]
+        add(pcnt.set_edge_mode(RawExpression(rising_edge), RawExpression(falling_edge)))
+    if CONF_INTERNAL_FILTER in config:
+        add(pcnt.set_filter(config[CONF_INTERNAL_FILTER]))
+    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)

esphomeyaml/components/sensor/ultrasonic.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ECHO_PIN, CONF_ID, CONF_NAME, \
+    CONF_TIMEOUT_METER, CONF_TIMEOUT_TIME, CONF_TRIGGER_PIN, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, add, exp_gpio_input_pin, exp_gpio_output_pin, \
+    variable
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('ultrasonic'): cv.register_variable_id,
+    vol.Required(CONF_TRIGGER_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_ECHO_PIN): pins.GPIO_INPUT_PIN_SCHEMA,
+    vol.Exclusive(CONF_TIMEOUT_METER, 'timeout'): cv.positive_float,
+    vol.Exclusive(CONF_TIMEOUT_TIME, 'timeout'): cv.positive_int,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    trigger = exp_gpio_output_pin(config[CONF_TRIGGER_PIN])
+    echo = exp_gpio_input_pin(config[CONF_ECHO_PIN])
+    rhs = App.make_ultrasonic_sensor(trigger, echo, config[CONF_NAME],
+                                     config.get(CONF_UPDATE_INTERVAL))
+    make = variable('Application::MakeUltrasonicSensor', config[CONF_ID], rhs)
+    ultrasonic = make.Pultrasonic
+    if CONF_TIMEOUT_TIME in config:
+        add(ultrasonic.set_timeout_us(config[CONF_TIMEOUT_TIME]))
+    elif CONF_TIMEOUT_METER in config:
+        add(ultrasonic.set_timeout_m(config[CONF_TIMEOUT_METER]))
+    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)

esphomeyaml/components/switch/__init__.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ICON, CONF_ID, CONF_NAME
+from esphomeyaml.helpers import App, Pvariable, add, setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+MQTT_SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    vol.Optional(CONF_ICON): cv.icon,
+})
+
+
+def setup_mqtt_switch(obj, config):
+    if CONF_ICON in config:
+        add(obj.set_icon(config[CONF_ICON]))
+    setup_mqtt_component(obj, config)
+
+
+def make_mqtt_switch_for(exp, config):
+    rhs = App.make_mqtt_switch_for(exp, config[CONF_NAME])
+    mqtt_switch = Pvariable('switch_::MQTTSwitchComponent', config[CONF_ID], rhs)
+    setup_mqtt_switch(mqtt_switch, config)

esphomeyaml/components/switch/gpio.py

@@ -0,0 +1,18 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, exp_gpio_output_pin, variable
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('gpio_switch'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_gpio_switch(exp_gpio_output_pin(config[CONF_PIN]), config[CONF_NAME])
+    gpio = variable('Application::GPIOSwitchStruct', config[CONF_ID], rhs)
+    switch.setup_mqtt_switch(gpio.Pmqtt, config)

esphomeyaml/components/switch/ir_transmitter.py

@@ -0,0 +1,87 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import switch
+from esphomeyaml.components.ir_transmitter import IR_TRANSMITTER_COMPONENT_CLASS
+from esphomeyaml.const import CONF_ADDRESS, CONF_COMMAND, CONF_DATA, CONF_IR_TRANSMITTER_ID, \
+    CONF_LG, CONF_NBITS, CONF_NEC, CONF_PANASONIC, CONF_REPEAT, CONF_SONY, CONF_TIMES, \
+    CONF_WAIT_TIME_US, CONF_RAW, CONF_CARRIER_FREQUENCY
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import HexIntLiteral, MockObj, get_variable, ArrayInitializer
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('ir_transmitter'): cv.register_variable_id,
+    vol.Exclusive(CONF_NEC, 'code'): vol.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint16_t,
+    }),
+    vol.Exclusive(CONF_LG, 'code'): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), vol.Range(min=0, max=32)),
+    }),
+    vol.Exclusive(CONF_SONY, 'code'): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), vol.Range(min=0, max=32)),
+    }),
+    vol.Exclusive(CONF_PANASONIC, 'code'): vol.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
+    }),
+    vol.Exclusive(CONF_RAW, 'code'): vol.Schema({
+        vol.Required(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
+        vol.Required(CONF_DATA): [vol.Coerce(int)],
+    }),
+    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, vol.Schema({
+        vol.Required(CONF_TIMES): cv.positive_not_null_int,
+        vol.Required(CONF_WAIT_TIME_US): cv.uint32_t,
+    })),
+    vol.Optional(CONF_IR_TRANSMITTER_ID): cv.variable_id,
+}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+
+SendData = MockObj('switch_::ir::SendData', '::')
+
+
+def safe_hex(value):
+    if value is None:
+        return None
+    return HexIntLiteral(value)
+
+
+def exp_send_data(config):
+    if CONF_NEC in config:
+        conf = config[CONF_NEC]
+        base = SendData.from_nec(safe_hex(conf[CONF_ADDRESS]),
+                                 safe_hex(conf[CONF_COMMAND]))
+    elif CONF_LG in config:
+        conf = config[CONF_LG]
+        base = SendData.from_lg(safe_hex(conf[CONF_DATA]), conf.get(CONF_NBITS))
+    elif CONF_SONY in config:
+        conf = config[CONF_SONY]
+        base = SendData.from_sony(safe_hex(conf[CONF_DATA]), conf.get(CONF_NBITS))
+    elif CONF_PANASONIC in config:
+        conf = config[CONF_PANASONIC]
+        base = SendData.from_panasonic(safe_hex(conf[CONF_ADDRESS]),
+                                       safe_hex(conf[CONF_COMMAND]))
+    elif CONF_RAW in config:
+        conf = config[CONF_RAW]
+        data = ArrayInitializer(*conf[CONF_DATA])
+        base = SendData.from_raw(data, conf[CONF_CARRIER_FREQUENCY])
+    else:
+        raise ESPHomeYAMLError(u"Unsupported IR mode {}".format(config))
+
+    if CONF_REPEAT in config:
+        if isinstance(config[CONF_REPEAT], int):
+            times = config[CONF_REPEAT]
+            wait_us = None
+        else:
+            times = config[CONF_REPEAT][CONF_TIMES]
+            wait_us = config[CONF_REPEAT][CONF_WAIT_TIME_US]
+        base = MockObj(unicode(base), u'.')
+        base = base.repeat(times, wait_us)
+    return base
+
+
+def to_code(config):
+    ir = get_variable(config.get(CONF_IR_TRANSMITTER_ID), IR_TRANSMITTER_COMPONENT_CLASS)
+    send_data = exp_send_data(config)
+    switch.make_mqtt_switch_for(ir.create_transmitter(send_data), config)

esphomeyaml/components/switch/restart.py

@@ -0,0 +1,14 @@
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_ID, CONF_NAME
+from esphomeyaml.helpers import App, Pvariable
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('restart_switch'): cv.register_variable_id,
+}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_restart_switch(config[CONF_NAME])
+    mqtt = Pvariable('switch_::MQTTSwitchComponent', config[CONF_ID], rhs)
+    switch.setup_mqtt_switch(mqtt, config)

esphomeyaml/components/wifi.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_DNS1, CONF_DNS2, CONF_GATEWAY, CONF_HOSTNAME, CONF_ID, \
+    CONF_MANUAL_IP, CONF_PASSWORD, CONF_SSID, CONF_STATIC_IP, CONF_SUBNET, CONF_WIFI
+from esphomeyaml.helpers import App, MockObj, Pvariable, StructInitializer, add
+
+CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+    cv.GenerateID(CONF_WIFI): cv.register_variable_id,
+    vol.Required(CONF_SSID): cv.ssid,
+    vol.Optional(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_MANUAL_IP): vol.Schema({
+        vol.Required(CONF_STATIC_IP): cv.ipv4,
+        vol.Required(CONF_GATEWAY): cv.ipv4,
+        vol.Required(CONF_SUBNET): cv.ipv4,
+        vol.Inclusive(CONF_DNS1, 'dns'): cv.ipv4,
+        vol.Inclusive(CONF_DNS2, 'dns'): cv.ipv4,
+    }),
+    vol.Optional(CONF_HOSTNAME): cv.hostname,
+})
+
+IPAddress = MockObj('IPAddress')
+
+
+def safe_ip(ip):
+    if ip is None:
+        return None
+    return IPAddress(*ip.args)
+
+
+def to_code(config):
+    rhs = App.init_wifi(config[CONF_SSID], config.get(CONF_PASSWORD))
+    wifi = Pvariable('WiFiComponent', config[CONF_ID], rhs)
+    if CONF_MANUAL_IP in config:
+        manual_ip = config[CONF_MANUAL_IP]
+        exp = StructInitializer(
+            'ManualIP',
+            ('static_ip', safe_ip(manual_ip[CONF_STATIC_IP])),
+            ('gateway', safe_ip(manual_ip[CONF_GATEWAY])),
+            ('subnet', safe_ip(manual_ip[CONF_SUBNET])),
+            ('dns1', safe_ip(manual_ip.get(CONF_DNS1))),
+            ('dns2', safe_ip(manual_ip.get(CONF_DNS2))),
+        )
+        add(wifi.set_manual_ip(exp))
+    if CONF_HOSTNAME in config:
+        add(wifi.set_hostname(config[CONF_HOSTNAME]))