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)