Initial Commit 🎉

.dockerignore

@@ -0,0 +1,108 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+config/
+examples/
+Dockerfile

.gitignore

@@ -0,0 +1,106 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+config/

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:2.7
+MAINTAINER Otto Winter <contact@otto-winter.com>
+
+ENV ESPHOMEYAML_OTA_HOST_PORT=6123
+EXPOSE 6123
+VOLUME /config
+WORKDIR /usr/src/app
+
+COPY requirements.txt /usr/src/app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY docker/platformio.ini /usr/src/app/
+RUN platformio settings set enable_telemetry No && \
+    platformio lib --global install esphomelib && \
+    platformio run -e espressif32 -e espressif8266; exit 0
+
+# Fix issue with static IP on ESP32: https://github.com/espressif/arduino-esp32/issues/1081
+RUN curl https://github.com/espressif/arduino-esp32/commit/144480637a718844b8f48f4392da8d4f622f2e5e.patch | \
+    patch /root/.platformio/packages/framework-arduinoespressif32/libraries/WiFi/src/WiFiGeneric.cpp
+
+COPY . .
+RUN pip install -e .
+
+WORKDIR /config
+ENTRYPOINT ["esphomeyaml"]

README.md

@@ -0,0 +1,37 @@
+# esphomeyaml for [esphomelib](https://github.com/OttoWinter/esphomelib)
+
+Getting Started Guide: https://esphomlib.com/esphomeyaml/getting-started.html
+Available Components: https://esphomelib.com/esphomeyaml/index.html
+
+esphomeyaml is the solution for your ESP8266/ESP32 projects with Home Assistant. It allows you to create **custom firmwares** for your microcontrollers with no programming experience required. All you need to know is the YAML configuration format which is also used by Home Assistant.
+
+esphomeyaml will:
+
+ * Read your configuration file and warn you about potential errors (like using the invalid pins.)
+ * Create a custom C++ sketch file for you using esphomeyaml's powerful C++ generation engine.
+ * Compile the sketch file for you using [platformio](http://platformio.org/).
+ * Upload the binary to your ESP via Over the Air updates.
+ * Automatically start remote logs via MQTT.
+
+And all of that with a single command 🎉:
+
+```bash
+esphomeyaml configuration.yaml run
+```
+
+## Features
+
+ * **No programming experience required:** just edit YAML configuration
+    files like you're used to with Home Assistant.
+ * **Flexible:** Use [esphomelib](https://github.com/OttoWinter/esphomelib)'s powerful core to create custom sensors/outputs.
+ * **Fast and efficient:** Written in C++ and keeps memory consumption to a minimum.
+ * **Made for Home Assistant:** Almost all Home Assistant features are supported out of the box. Including RGB lights and many more.
+ * **Easy reproducible configuration:** No need to go through a long setup process for every single node. Just copy a configuration file and run a single command.
+ * **Smart Over The Air Updates:** esphomeyaml has OTA updates deeply integrated into the system. It even automatically enters a recovery mode if a boot loop is detected.
+ * **Powerful logging engine:** View colorful logs and debug issues remotely.
+ * **Open Source**
+ * For me: Makes documenting esphomelib's features a lot easier.
+
+## Special Thanks
+
+Special Thanks to the Home Assistant project. Lots of the code base of esphomeyaml is based off of Home Assistant, for example the loading and config validation code.

docker/platformio.ini

@@ -0,0 +1,12 @@
+; This file allows the docker build file to install the required platformio
+; platforms
+
+[env:espressif32]
+platform = espressif32
+board = nodemcu-32s
+framework = arduino
+
+[env:espressif8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino

esphomeyaml/__main__.py

@@ -0,0 +1,306 @@
+from __future__ import print_function
+
+import argparse
+import logging
+import os
+import random
+import sys
+
+from esphomeyaml import helpers, mqtt, writer, yaml_util, wizard
+from esphomeyaml.config import add_component_task, read_config
+from esphomeyaml.const import CONF_ESPHOMEYAML, CONF_HOSTNAME, CONF_MANUAL_IP, CONF_NAME, \
+    CONF_STATIC_IP, \
+    CONF_WIFI, CONF_LOGGER, CONF_BAUD_RATE
+from esphomeyaml.helpers import AssignmentExpression, RawStatement, _EXPRESSIONS, add, \
+    get_variable, indent, quote, statement
+
+_LOGGER = logging.getLogger(__name__)
+
+PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'i2c']
+
+CONFIG_PATH = None
+
+
+def get_name(config):
+    return config[CONF_ESPHOMEYAML][CONF_NAME]
+
+
+def get_base_path(config):
+    return os.path.join(os.path.dirname(CONFIG_PATH), get_name(config))
+
+
+def discover_serial_ports():
+    # from https://github.com/pyserial/pyserial/blob/master/serial/tools/list_ports.py
+    try:
+        from serial.tools.list_ports import comports
+    except ImportError:
+        return None
+
+    result = None
+    for p, d, h in comports():
+        if not p:
+            continue
+        if "VID:PID" in h:
+            if result is not None:
+                return None
+            result = p
+
+    return result
+
+
+def run_platformio(*cmd):
+    def mock_exit(rc):
+        raise SystemExit(rc)
+
+    orig_argv = sys.argv
+    orig_exit = sys.exit  # mock sys.exit
+    full_cmd = u' '.join(quote(x) for x in cmd)
+    _LOGGER.info(u"Running:  %s", full_cmd)
+    try:
+        import platformio.__main__
+        sys.argv = list(cmd)
+        sys.exit = mock_exit
+        return platformio.__main__.main()
+    except KeyboardInterrupt:
+        return 1
+    except SystemExit as e:
+        return e.args[0]
+    except Exception as e:
+        _LOGGER.error(u"Running platformio failed: %s", e)
+        _LOGGER.error(u"Please try running %s locally.", full_cmd)
+    finally:
+        sys.argv = orig_argv
+        sys.exit = orig_exit
+
+
+def run_miniterm(config, port):
+    from serial.tools import miniterm
+    baud_rate = config.get(CONF_LOGGER, {}).get(CONF_BAUD_RATE, 115200)
+    sys.argv = ['miniterm', '--raw', '--exit-char', '3']
+    miniterm.main(
+        default_port=port,
+        default_baudrate=baud_rate)
+
+
+def write_cpp(config):
+    _LOGGER.info("Generating C++ source...")
+    for domain in PRE_INITIALIZE:
+        if domain in config:
+            add_component_task(domain, config[domain])
+
+    # Clear queue
+    get_variable(None)
+    add(RawStatement(''))
+
+    for domain, conf in config.iteritems():
+        if domain in PRE_INITIALIZE:
+            continue
+        add_component_task(domain, conf)
+
+    # Clear queue
+    get_variable(None)
+    add(RawStatement(''))
+    add(RawStatement(''))
+
+    all_code = []
+    for exp in _EXPRESSIONS:
+        if helpers.SIMPLIFY and isinstance(exp, AssignmentExpression) and exp.obj.usages == 0:
+            exp = exp.rhs
+        all_code.append(unicode(statement(exp)))
+
+    platformio_ini_s = writer.get_ini_content(config)
+    ini_path = os.path.join(get_base_path(config), 'platformio.ini')
+    writer.write_platformio_ini(platformio_ini_s, ini_path)
+
+    code_s = indent('\n'.join(all_code))
+    cpp_path = os.path.join(get_base_path(config), 'src', 'main.cpp')
+    writer.write_cpp(code_s, cpp_path)
+    return 0
+
+
+def compile_program(config):
+    _LOGGER.info("Compiling app...")
+    return run_platformio('platformio', 'run', '-d', get_base_path(config))
+
+
+def upload_program(config, args, port):
+    _LOGGER.info("Uploading binary...")
+    if args.upload_port is not None:
+        if args.upload_port == 'HELLO':
+            return run_platformio('platformio', 'run', '-d', get_base_path(config),
+                                  '-t', 'upload')
+        else:
+            return run_platformio('platformio', 'run', '-d', get_base_path(config),
+                                  '-t', 'upload', '--upload-port', args.upload_port)
+
+    if port is not None:
+        _LOGGER.info("Serial device discovered, using it for upload")
+        return run_platformio('platformio', 'run', '-d', get_base_path(config),
+                              '-t', 'upload', '--upload-port', port)
+
+    if CONF_MANUAL_IP in config[CONF_WIFI]:
+        host = str(config[CONF_WIFI][CONF_MANUAL_IP][CONF_STATIC_IP])
+    elif CONF_HOSTNAME in config[CONF_WIFI]:
+        host = config[CONF_WIFI][CONF_HOSTNAME] + u'.local'
+    else:
+        host = config[CONF_ESPHOMEYAML][CONF_NAME] + u'.local'
+
+    from esphomeyaml.components import ota
+    from esphomeyaml import espota
+
+    bin_file = os.path.join(get_base_path(config), '.pioenvs', get_name(config), 'firmware.bin')
+    if args.host_port is not None:
+        host_port = args.host_port
+    else:
+        host_port = int(os.getenv('ESPHOMEYAML_OTA_HOST_PORT', random.randint(10000, 60000)))
+    espota_args = ['espota.py', '--debug', '--progress', '-i', host,
+                   '-p', str(ota.get_port(config)), '-f', bin_file,
+                   '-a', ota.get_auth(config), '-P', str(host_port)]
+    return espota.main(espota_args)
+
+
+def show_logs(config, args, port):
+    if port is not None:
+        run_miniterm(config, port)
+        return 0
+    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+
+
+def clean_mqtt(config, args):
+    return mqtt.clear_topic(config, args.topic, args.username, args.password, args.client_id)
+
+
+def setup_log():
+    logging.basicConfig(level=logging.INFO)
+    fmt = "%(levelname)s [%(name)s] %(message)s"
+    colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
+    datefmt = '%H:%M:%S'
+
+    logging.getLogger('urllib3').setLevel(logging.WARNING)
+
+    try:
+        from colorlog import ColoredFormatter
+        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
+            colorfmt,
+            datefmt=datefmt,
+            reset=True,
+            log_colors={
+                'DEBUG': 'cyan',
+                'INFO': 'green',
+                'WARNING': 'yellow',
+                'ERROR': 'red',
+                'CRITICAL': 'red',
+            }
+        ))
+    except ImportError:
+        pass
+
+
+def main():
+    global CONFIG_PATH
+
+    setup_log()
+
+    parser = argparse.ArgumentParser(prog='esphomeyaml')
+    parser.add_argument('configuration', help='Your YAML configuration file.')
+    subparsers = parser.add_subparsers(help='Commands', dest='command')
+    subparsers.required = True
+    parser_config = subparsers.add_parser('config',
+                                          help='Validate the configuration and spit it out.')
+
+    parser_compile = subparsers.add_parser('compile',
+                                           help='Read the configuration and compile a program.')
+
+    parser_upload = subparsers.add_parser('upload', help='Validate the configuration '
+                                                         'and upload the latest binary.')
+    parser_upload.add_argument('--upload-port', help="Manually specify the upload port to use. "
+                                                     "For example /dev/cu.SLAB_USBtoUAR.",
+                               nargs='?', const='HELLO')
+    parser_upload.add_argument('--host-port', help="Specify the host port.", type=int)
+
+    parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
+                                                     'and show all MQTT logs.')
+    parser_logs.add_argument('--topic', help='Manually set the topic to subscribe to.')
+    parser_logs.add_argument('--username', help='Manually set the username.')
+    parser_logs.add_argument('--password', help='Manually set the password.')
+    parser_logs.add_argument('--client-id', help='Manually set the client id.')
+
+    parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
+                                                   'upload it, and start MQTT logs.')
+    parser_run.add_argument('--upload-port', help="Manually specify the upload port to use. "
+                                                  "For example /dev/cu.SLAB_USBtoUAR.",
+                            nargs='?', const='HELLO')
+    parser_run.add_argument('--host-port', help="Specify the host port to use for OTA", type=int)
+    parser_run.add_argument('--no-logs', help='Disable starting MQTT logs.',
+                            action='store_true')
+    parser_run.add_argument('--topic', help='Manually set the topic to subscribe to for logs.')
+    parser_run.add_argument('--username', help='Manually set the MQTT username for logs.')
+    parser_run.add_argument('--password', help='Manually set the MQTT password for logs.')
+    parser_run.add_argument('--client-id', help='Manually set the client id for logs.')
+
+    parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
+                                                            "retain messages.")
+    parser_clean.add_argument('--topic', help='Manually set the topic to subscribe to.')
+    parser_clean.add_argument('--username', help='Manually set the username.')
+    parser_clean.add_argument('--password', help='Manually set the password.')
+    parser_clean.add_argument('--client-id', help='Manually set the client id.')
+
+    parser_wizard = subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
+                                                         "you through setting up esphomeyaml.")
+
+    args = parser.parse_args()
+
+    if args.command == 'wizard':
+        return wizard.wizard(args.configuration)
+
+    CONFIG_PATH = args.configuration
+    config = read_config(CONFIG_PATH)
+    if config is None:
+        return 1
+
+    if args.command == 'config':
+        print(yaml_util.dump(config))
+    elif args.command == 'compile':
+        exit_code = write_cpp(config)
+        if exit_code != 0:
+            return exit_code
+        exit_code = compile_program(config)
+        if exit_code != 0:
+            return exit_code
+        _LOGGER.info(u"Successfully compiled program.")
+        return 0
+    elif args.command == 'upload':
+        port = discover_serial_ports()
+        exit_code = upload_program(config, args, port)
+        if exit_code != 0:
+            return exit_code
+        _LOGGER.info(u"Successfully uploaded program.")
+        return 0
+    elif args.command == 'logs':
+        port = discover_serial_ports()
+        return show_logs(config, args, port)
+    elif args.command == 'clean-mqtt':
+        return clean_mqtt(config, args)
+    elif args.command == 'run':
+        exit_code = write_cpp(config)
+        if exit_code != 0:
+            return exit_code
+        exit_code = compile_program(config)
+        if exit_code != 0:
+            return exit_code
+        _LOGGER.info(u"Successfully compiled program.")
+        if args.no_logs:
+            return
+        port = discover_serial_ports()
+        exit_code = upload_program(config, args, port)
+        if exit_code != 0:
+            return exit_code
+        _LOGGER.info(u"Successfully uploaded program.")
+        return show_logs(config, args, port)
+    else:
+        print(u"Unknown command {}".format(args.command))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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]))

esphomeyaml/config.py

@@ -0,0 +1,280 @@
+from __future__ import print_function
+
+import importlib
+import logging
+from collections import OrderedDict
+
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import helpers, yaml_util
+from esphomeyaml.const import CONF_BOARD, CONF_ESPHOMEYAML, CONF_LIBRARY_URI, CONF_MQTT, \
+    CONF_NAME, \
+    CONF_PLATFORM, CONF_SIMPLIFY, CONF_WIFI, ESP_PLATFORMS, ESP_PLATFORM_ESP32, \
+    ESP_PLATFORM_ESP8266
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, add, add_task, color
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_LIBRARY_URI = u'esphomelib'
+
+CORE_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.valid_name,
+    vol.Required(CONF_PLATFORM): vol.All(
+        vol.Upper, vol.Any(ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266)),
+    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,
+})
+
+REQUIRED_COMPONENTS = [
+    CONF_ESPHOMEYAML, CONF_WIFI, CONF_MQTT
+]
+
+_COMPONENT_CACHE = {}
+_ALL_COMPONENTS = []
+
+
+def core_to_code(config):
+    add(App.set_name(config[CONF_NAME]))
+
+
+def get_component(domain):
+    if domain in _COMPONENT_CACHE:
+        return _COMPONENT_CACHE[domain]
+
+    path = 'esphomeyaml.components.{}'.format(domain)
+    try:
+        module = importlib.import_module(path)
+    except ImportError as err:
+        _LOGGER.debug(err)
+        pass
+    else:
+        _COMPONENT_CACHE[domain] = module
+        return module
+
+    _LOGGER.error("Unable to find component %s", domain)
+    return None
+
+
+def get_platform(domain, platform):
+    return get_component("{}.{}".format(domain, platform))
+
+
+def is_platform_component(component):
+    return hasattr(component, 'PLATFORM_SCHEMA')
+
+
+def validate_schema(config, schema):
+    return schema(config)
+
+
+class Config(OrderedDict):
+    def __init__(self):
+        super(Config, self).__init__()
+        self.errors = []
+
+    def add_error(self, message, domain=None, config=None):
+        if not isinstance(message, unicode):
+            message = unicode(message)
+        self.errors.append((message, domain, config))
+
+
+def validate_config(config):
+    global _ALL_COMPONENTS
+
+    for req in REQUIRED_COMPONENTS:
+        if req not in config:
+            raise ESPHomeYAMLError("Component %s is required for esphomeyaml.", req)
+
+    _ALL_COMPONENTS = list(config.keys())
+
+    result = Config()
+
+    def _comp_error(ex, domain, config):
+        result.add_error(_format_config_error(ex, domain, config), domain, config)
+
+    try:
+        result[CONF_ESPHOMEYAML] = validate_schema(config[CONF_ESPHOMEYAML], CORE_SCHEMA)
+    except vol.Invalid as ex:
+        _comp_error(ex, CONF_ESPHOMEYAML, config)
+
+    for domain, conf in config.iteritems():
+        if domain == CONF_ESPHOMEYAML:
+            continue
+        if conf is None:
+            conf = {}
+        component = get_component(domain)
+        if component is None:
+            result.add_error(u"Component not found: {}".format(domain))
+            continue
+
+        esp_platforms = getattr(component, 'ESP_PLATFORMS', ESP_PLATFORMS)
+        if cv.ESP_PLATFORM not in esp_platforms:
+            result.add_error(u"Component {} doesn't support {}.".format(domain, cv.ESP_PLATFORM))
+            continue
+
+        success = True
+        dependencies = getattr(component, 'DEPENDENCIES', [])
+        for dependency in dependencies:
+            if dependency not in _ALL_COMPONENTS:
+                result.add_error(u"Component {} requires {}".format(domain, dependency))
+                success = False
+        if not success:
+            continue
+
+        if hasattr(component, 'CONFIG_SCHEMA'):
+            try:
+                validated = component.CONFIG_SCHEMA(conf)
+                result[domain] = validated
+            except vol.Invalid as ex:
+                _comp_error(ex, domain, config)
+                continue
+
+        if not hasattr(component, 'PLATFORM_SCHEMA'):
+            continue
+
+        platforms = []
+        for i, p_config in enumerate(conf):
+            if not isinstance(p_config, dict):
+                result.add_error(u"Platform schemas mus have 'platform:' key")
+                continue
+            p_name = p_config.get(u'platform')
+            if p_name is None:
+                result.add_error(u"No platform specified for {}".format(domain))
+                continue
+            platform = get_platform(domain, p_name)
+            if platform is None:
+                result.add_error(u"Platform not found: {}.{}")
+                continue
+
+            if hasattr(platform, u'PLATFORM_SCHEMA'):
+                try:
+                    p_validated = platform.PLATFORM_SCHEMA(p_config)
+                except vol.Invalid as ex:
+                    _comp_error(ex, u'{}.{}'.format(domain, p_name), p_config)
+                    continue
+                platforms.append(p_validated)
+        result[domain] = platforms
+    return result
+
+
+REQUIRED = ['esphomeyaml', 'wifi', 'mqtt']
+
+
+def _format_config_error(ex, domain, config):
+    message = u"Invalid config for [{}]: ".format(domain)
+    if u'extra keys not allowed' in ex.error_message:
+        message += u'[{}] is an invalid option for [{}]. Check: {}->{}.' \
+            .format(ex.path[-1], domain, domain,
+                    u'->'.join(str(m) for m in ex.path))
+    else:
+        message += u'{}.'.format(humanize_error(config, ex))
+
+    domain_config = config.get(domain, config)
+    message += u" (See {}, line {}). ".format(
+        getattr(domain_config, '__config_file__', '?'),
+        getattr(domain_config, '__line__', '?'))
+
+    return message
+
+
+def load_config(path):
+    try:
+        config = yaml_util.load_yaml(path)
+    except OSError:
+        raise ESPHomeYAMLError(u"Could not read configuration file at {}".format(path))
+
+    esp_platform = unicode(config.get(CONF_ESPHOMEYAML, {}).get(CONF_PLATFORM, u""))
+    esp_platform = esp_platform.upper()
+    if esp_platform not in (ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266):
+        raise ESPHomeYAMLError(u"Invalid ESP Platform {}".format(esp_platform))
+    cv.ESP_PLATFORM = esp_platform
+    cv.BOARD = unicode(config.get(CONF_ESPHOMEYAML, {}).get(CONF_BOARD, u""))
+    helpers.SIMPLIFY = cv.boolean(config.get(CONF_SIMPLIFY, True))
+
+    try:
+        result = validate_config(config)
+    except Exception as e:
+        print(u"Unexpected exception while reading configuration:")
+        raise
+
+    return result
+
+
+def add_platform_task(domain, config):
+    platform_ = config[CONF_PLATFORM]
+    platform = get_platform(domain, platform_)
+    if not hasattr(platform, 'to_code'):
+        raise ESPHomeYAMLError(u"Platform '{}.{}' doesn't have to_code.".format(domain, platform_))
+    add_task(platform.to_code, config)
+
+
+def add_component_task(domain, config):
+    if domain == CONF_ESPHOMEYAML:
+        add_task(core_to_code, config)
+        return
+    component = get_component(domain)
+    if is_platform_component(component):
+        for conf in config:
+            add_platform_task(domain, conf)
+    else:
+        if not hasattr(component, 'to_code'):
+            raise ESPHomeYAMLError(u"Component '{}' doesn't have to_code.".format(domain))
+        add_task(component.to_code, config)
+
+
+def line_info(obj, **kwargs):
+    """Display line config source."""
+    if hasattr(obj, '__config_file__'):
+        return color('cyan', "[source {}:{}]"
+                     .format(obj.__config_file__, obj.__line__ or '?'),
+                     **kwargs)
+    return '?'
+
+
+def dump_dict(layer, indent_count=3, listi=False, **kwargs):
+    def sort_dict_key(val):
+        """Return the dict key for sorting."""
+        key = str.lower(val[0])
+        return '0' if key == 'platform' else key
+
+    indent_str = indent_count * ' '
+    if listi or isinstance(layer, list):
+        indent_str = indent_str[:-1] + '-'
+    if isinstance(layer, dict):
+        for key, value in sorted(layer.items(), key=sort_dict_key):
+            if isinstance(value, (dict, list)):
+                print(indent_str, key + ':', line_info(value, **kwargs))
+                dump_dict(value, indent_count + 2)
+            else:
+                print(indent_str, key + ':', value)
+            indent_str = indent_count * ' '
+    if isinstance(layer, (list, tuple)):
+        for i in layer:
+            if isinstance(i, dict):
+                dump_dict(i, indent_count + 2, True)
+            else:
+                print(' ', indent_str, i)
+
+
+def read_config(path):
+    _LOGGER.debug("Reading configuration...")
+    res = load_config(path)
+    excepts = {}
+    for err in res.errors:
+        domain = err[1] or u"General Error"
+        excepts.setdefault(domain, []).append(err[0])
+        if err[2] is not None:
+            excepts[domain].append(err[2])
+
+    if excepts:
+        print(color('bold_white', u"Failed config"))
+        for domain, config in excepts.iteritems():
+            print(' ', color('bold_red', domain + ':'), color('red', '', reset='red'))
+            dump_dict(config, reset='red')
+            print(color('reset'))
+        return None
+    return dict(**res)

esphomeyaml/config_validation.py

@@ -0,0 +1,372 @@
+# coding=utf-8
+"""Helpers for config validation using voluptuous."""
+from __future__ import print_function
+
+import logging
+from datetime import timedelta
+
+import voluptuous as vol
+
+from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_ID, \
+    CONF_NAME, CONF_PAYLOAD_AVAILABLE, \
+    CONF_PAYLOAD_NOT_AVAILABLE, CONF_PLATFORM, CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC, \
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
+from esphomeyaml.core import HexInt, IPAddress
+from esphomeyaml.helpers import ensure_unique_string
+
+_LOGGER = logging.getLogger(__name__)
+
+port = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
+positive_float = vol.All(vol.Coerce(float), vol.Range(min=0))
+zero_to_one_float = vol.All(vol.Coerce(float), vol.Range(min=0, max=1)),
+positive_int = vol.All(vol.Coerce(int), vol.Range(min=0))
+positive_not_null_int = vol.All(vol.Coerce(int), vol.Range(min=0, min_included=False))
+
+ESP_PLATFORM = ''
+BOARD = ''
+
+ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
+
+RESERVED_IDS = [
+    # C++ keywords http://en.cppreference.com/w/cpp/keyword
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'bool', 'break',
+    'case', 'catch', 'char', 'char16_t', 'char32_t', 'class', 'compl', 'concept', 'const',
+    'constexpr', 'const_cast', 'continue', 'decltype', 'default', 'delete', 'do', 'double',
+    'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'export', 'extern', 'false', 'float',
+    'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',
+    'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'private', 'protected',
+    'public', 'register', 'reinterpret_cast', 'requires', 'return', 'short', 'signed', 'sizeof',
+    'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',
+    'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename', 'union', 'unsigned',
+    'using', 'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq',
+
+    'App', 'pinMode', 'delay', 'delayMicroseconds', 'digitalRead', 'digitalWrite', 'INPUT',
+    'OUTPUT',
+]
+
+
+def alphanumeric(value):
+    if value is None:
+        raise vol.Invalid("string value is None")
+    value = unicode(value)
+    if not value.isalnum():
+        raise vol.Invalid("string value is not alphanumeric")
+    return value
+
+
+def valid_name(value):
+    value = string_strict(value)
+    if not all(c in ALLOWED_NAME_CHARS for c in value):
+        raise vol.Invalid(u"Valid characters for name are %s", ALLOWED_NAME_CHARS)
+    return value
+
+
+def string(value):
+    if isinstance(value, (dict, list)):
+        raise vol.Invalid("string value cannot be dictionary or list.")
+    if value is not None:
+        return unicode(value)
+    raise vol.Invalid("string value is None")
+
+
+def string_strict(value):
+    """Strictly only allow strings."""
+    if isinstance(value, str) or isinstance(value, unicode):
+        return value
+    raise vol.Invalid("Must be string, did you forget putting quotes "
+                      "around the value?")
+
+
+def icon(value):
+    """Validate icon."""
+    value = string_strict(value)
+    if value.startswith('mdi:'):
+        return value
+    raise vol.Invalid('Icons should start with prefix "mdi:"')
+
+
+def boolean(value):
+    """Validate and coerce a boolean value."""
+    if isinstance(value, str):
+        value = value.lower()
+        if value in ('1', 'true', 'yes', 'on', 'enable'):
+            return True
+        if value in ('0', 'false', 'no', 'off', 'disable'):
+            return False
+        raise vol.Invalid('invalid boolean value {}'.format(value))
+    return bool(value)
+
+
+def ensure_list(value):
+    """Wrap value in list if it is not one."""
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def ensure_dict(value):
+    if value is None:
+        return {}
+    if not isinstance(value, dict):
+        raise vol.Invalid("Expected a dictionary")
+    return value
+
+
+def hex_int_(value):
+    if isinstance(value, (int, long)):
+        return HexInt(value)
+    value = string_strict(value).lower()
+    if value.startswith('0x'):
+        return HexInt(int(value, 16))
+    return HexInt(int(value))
+
+
+def int_(value):
+    if isinstance(value, (int, long)):
+        return value
+    value = string_strict(value).lower()
+    if value.startswith('0x'):
+        return int(value, 16)
+    return int(value)
+
+
+hex_int = vol.Coerce(hex_int_)
+match_cpp_var_ = vol.Match(r'^[a-zA-Z_][a-zA-Z0-9_]+$', msg=u"Must be a valid C++ variable name")
+
+
+def variable_id(value):
+    value = match_cpp_var_(value)
+    if value in RESERVED_IDS:
+        raise vol.Invalid(u"ID {} is reserved internally and cannot be used".format(value))
+    return value
+
+
+def only_on(platforms):
+    if not isinstance(platforms, list):
+        platforms = [platforms]
+
+    def validator_(obj):
+        print(obj)
+        if ESP_PLATFORM not in platforms:
+            raise vol.Invalid(u"This feature is only available on {}".format(platforms))
+        return obj
+
+    return validator_
+
+
+only_on_esp32 = only_on(ESP_PLATFORM_ESP32)
+only_on_esp8266 = only_on(ESP_PLATFORM_ESP8266)
+
+
+# Adapted from:
+# https://github.com/alecthomas/voluptuous/issues/115#issuecomment-144464666
+def has_at_least_one_key(*keys):
+    """Validate that at least one key exists."""
+
+    def validate(obj):
+        """Test keys exist in dict."""
+        if not isinstance(obj, dict):
+            raise vol.Invalid('expected dictionary')
+
+        for k in obj.keys():
+            if k in keys:
+                return obj
+        raise vol.Invalid('must contain one of {}.'.format(', '.join(keys)))
+
+    return validate
+
+
+TIME_PERIOD_ERROR = "Time period {} should be format 5ms, 5s, 5min, 5h"
+
+time_period_dict = vol.All(
+    dict, vol.Schema({
+        'days': vol.Coerce(int),
+        'hours': vol.Coerce(int),
+        'minutes': vol.Coerce(int),
+        'seconds': vol.Coerce(int),
+        'milliseconds': vol.Coerce(int),
+    }),
+    has_at_least_one_key('days', 'hours', 'minutes',
+                         'seconds', 'milliseconds'),
+    lambda value: timedelta(**value))
+
+
+def time_period_str(value):
+    """Validate and transform time offset."""
+    if isinstance(value, int):
+        raise vol.Invalid("Make sure you wrap time values in quotes")
+    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+    value = unicode(value)
+    if value.endswith(u'ms'):
+        return vol.Coerce(int)(value[:-2])
+    elif value.endswith(u's'):
+        return vol.Coerce(float)(value[:-1]) * 1000
+    elif value.endswith(u'min'):
+        return vol.Coerce(float)(value[:-3]) * 1000 * 60
+    elif value.endswith(u'h'):
+        return vol.Coerce(float)(value[:-1]) * 1000 * 60 * 60
+    raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+
+def time_period_milliseconds(value):
+    try:
+        return timedelta(milliseconds=int(value))
+    except (ValueError, TypeError):
+        raise vol.Invalid('Expected milliseconds, got {}'.format(value))
+
+
+def time_period_to_milliseconds(value):
+    if isinstance(value, (int, long)):
+        return value
+    if isinstance(value, float):
+        return int(value)
+    return value / timedelta(milliseconds=1)
+
+
+time_period = vol.All(vol.Any(time_period_str, timedelta, time_period_dict,
+                              time_period_milliseconds), time_period_to_milliseconds)
+positive_time_period = vol.All(time_period, vol.Range(min=0))
+positive_not_null_time_period = vol.All(time_period, vol.Range(min=0, min_included=False))
+
+
+METRIC_SUFFIXES = {
+    'E': 1e18, 'P': 1e15, 'T': 1e12, 'G': 1e9, 'M': 1e6, 'k': 1e3, 'da': 10, 'd': 1e-1,
+    'c': 1e-2, 'm': 0.001, u'µ': 1e-6, 'u': 1e-6, 'n': 1e-9, 'p': 1e-12, 'f': 1e-15, 'a': 1e-18,
+}
+
+
+def frequency(value):
+    value = string(value).replace(' ', '').lower()
+    if value.endswith('Hz') or value.endswith('hz') or value.endswith('HZ'):
+        value = value[:-2]
+    if not value:
+        raise vol.Invalid(u"Frequency must have value")
+    multiplier = 1
+    if value[:-1] in METRIC_SUFFIXES:
+        multiplier = METRIC_SUFFIXES[value[:-1]]
+        value = value[:-1]
+    elif len(value) >= 2 and value[:-2] in METRIC_SUFFIXES:
+        multiplier = METRIC_SUFFIXES[value[:-2]]
+        value = value[:-2]
+    float_val = vol.Coerce(float)(value)
+    return float_val * multiplier
+
+
+def hostname(value):
+    value = string(value)
+    if len(value) > 63:
+        raise vol.Invalid("Hostnames can only be 63 characters long")
+    for c in value:
+        if not (c.isalnum() or c in '_-'):
+            raise vol.Invalid("Hostname can only have alphanumeric characters and _ or -")
+    return value
+
+
+def ssid(value):
+    if value is None:
+        raise vol.Invalid("SSID can not be None")
+    if not isinstance(value, str):
+        raise vol.Invalid("SSID must be a string. Did you wrap it in quotes?")
+    if not value:
+        raise vol.Invalid("SSID can't be empty.")
+    if len(value) > 32:
+        raise vol.Invalid("SSID can't be longer than 32 characters")
+    return value
+
+
+def ipv4(value):
+    if isinstance(value, list):
+        parts = value
+    elif isinstance(value, str):
+        parts = value.split('.')
+    else:
+        raise vol.Invalid("IPv4 address must consist of either string or "
+                          "integer list")
+    if len(parts) != 4:
+        raise vol.Invalid("IPv4 address must consist of four point-separated "
+                          "integers")
+    parts_ = list(map(int, parts))
+    if not all(0 <= x < 256 for x in parts_):
+        raise vol.Invalid("IPv4 address parts must be in range from 0 to 255")
+    return IPAddress(*parts_)
+
+
+def publish_topic(value):
+    value = string_strict(value)
+    if value.endswith('/'):
+        raise vol.Invalid("Publish topic can't end with '/'")
+    return value
+
+
+subscribe_topic = string_strict  # TODO improve this
+mqtt_payload = string  # TODO improve this
+uint8_t = vol.All(int_, vol.Range(min=0, max=255))
+uint16_t = vol.All(int_, vol.Range(min=0, max=65535))
+uint32_t = vol.All(int_, vol.Range(min=0, max=4294967295))
+hex_uint8_t = vol.All(hex_int, vol.Range(min=0, max=255))
+hex_uint16_t = vol.All(hex_int, vol.Range(min=0, max=65535))
+hex_uint32_t = vol.All(hex_int, vol.Range(min=0, max=4294967295))
+i2c_address = hex_uint8_t
+
+
+def invalid(value):
+    raise vol.Invalid("This shouldn't happen.")
+
+
+def valid(value):
+    return value
+
+
+REGISTERED_IDS = set()
+
+
+def register_variable_id(value):
+    s = variable_id(value)
+    if s in REGISTERED_IDS:
+        raise vol.Invalid("This ID has already been used")
+    REGISTERED_IDS.add(s)
+    return s
+
+
+class GenerateID(vol.Optional):
+    def __init__(self, basename):
+        self._basename = basename
+        super(GenerateID, self).__init__(CONF_ID, default=self.default_variable_id)
+
+    def default_variable_id(self):
+        return ensure_unique_string(self._basename, REGISTERED_IDS)
+
+
+ID_SCHEMA = vol.Schema({
+    vol.Required(CONF_ID): invalid,
+})
+
+REQUIRED_ID_SCHEMA = vol.Schema({
+    vol.Required(CONF_ID): register_variable_id,
+})
+
+PLATFORM_SCHEMA = ID_SCHEMA.extend({
+    vol.Required(CONF_PLATFORM): valid,
+})
+
+MQTT_COMPONENT_AVAILABILITY_SCHEMA = vol.Schema({
+    vol.Required(CONF_TOPIC): subscribe_topic,
+    vol.Optional(CONF_PAYLOAD_AVAILABLE, default='online'): mqtt_payload,
+    vol.Optional(CONF_PAYLOAD_NOT_AVAILABLE, default='offline'): mqtt_payload,
+})
+
+MQTT_COMPONENT_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): string,
+    vol.Optional(CONF_RETAIN): boolean,
+    vol.Optional(CONF_DISCOVERY): boolean,
+    vol.Optional(CONF_STATE_TOPIC): publish_topic,
+    vol.Optional(CONF_AVAILABILITY): MQTT_COMPONENT_AVAILABILITY_SCHEMA,
+})
+
+MQTT_COMMAND_COMPONENT_SCHEMA = MQTT_COMPONENT_SCHEMA.extend({
+    vol.Optional(CONF_COMMAND_TOPIC): subscribe_topic,
+})