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