Bump version to 1.6.0

* HassIO Beginnings

* Updates

* Fix pylint errors

* Fix pylint error

Dockerfile

@@ -7,17 +7,13 @@ VOLUME /config
 WORKDIR /usr/src/app
 
 COPY requirements.txt /usr/src/app/
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir tornado esptool
 
 COPY docker/platformio.ini /usr/src/app/
 RUN platformio settings set enable_telemetry No && \
-    platformio lib --global install esphomelib@1.2.1 && \
     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 .
 

MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include esphomeyaml/dashboard/templates/index.html
+include esphomeyaml/dashboard/static/materialize-stepper.min.css
+include esphomeyaml/dashboard/static/materialize-stepper.min.js

esphomeyaml/Dockerfile

@@ -0,0 +1,20 @@
+# Dockerfile for HassIO add-on
+ARG BUILD_FROM
+FROM $BUILD_FROM
+
+ENV LANG C.UTF-8
+
+# Install requirements for add-on
+RUN apk add --no-cache python2 py2-pip git openssh libc6-compat && \
+    pip install --no-cache-dir platformio && \
+    platformio platform install espressif8266 \
+        --with-package tool-esptool \
+        --with-package framework-arduinoespressif8266 \
+        --with-package tool-mkspiffs \
+        --with-package tool-espotapy
+
+RUN pip install --no-cache-dir \
+      git+git://github.com/OttoWinter/esphomeyaml.git@v1.6.0 \
+      tornado esptool
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

esphomeyaml/__main__.py

@@ -1,24 +1,23 @@
 from __future__ import print_function
 
 import argparse
+from datetime import datetime
 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, color
+from esphomeyaml import const, core, mqtt, wizard, writer, yaml_util
+from esphomeyaml.config import core_to_code, get_component, iter_components, read_config
+from esphomeyaml.const import CONF_BAUD_RATE, CONF_DOMAIN, CONF_ESPHOMEYAML, CONF_HOSTNAME, \
+    CONF_LOGGER, CONF_MANUAL_IP, CONF_NAME, CONF_STATIC_IP, CONF_WIFI, ESP_PLATFORM_ESP8266
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import AssignmentExpression, Expression, RawStatement, _EXPRESSIONS, add, \
+    add_task, color, get_variable, indent, quote, statement
 
 _LOGGER = logging.getLogger(__name__)
 
-PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'i2c']
-
-CONFIG_PATH = None
+PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'web_server', 'i2c']
 
 
 def get_name(config):
@@ -26,33 +25,30 @@ def get_name(config):
 
 
 def get_base_path(config):
-    return os.path.join(os.path.dirname(CONFIG_PATH), get_name(config))
+    return os.path.join(os.path.dirname(core.CONFIG_PATH), get_name(config))
 
 
-def discover_serial_ports():
+def get_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
-
+    from serial.tools.list_ports import comports
     result = []
-    descs = []
     for port, desc, info in comports():
         if not port:
             continue
         if "VID:PID" in info:
-            result.append(port)
-            descs.append(desc)
+            result.append((port, desc))
+    return result
+
+
+def choose_serial_port(config):
+    result = get_serial_ports()
 
     if not result:
-        return None
-    if len(result) == 1:
-        return result[0]
+        return 'OTA'
     print(u"Found multiple serial port options, please choose one:")
-    for i, (res, desc) in enumerate(zip(result, descs)):
+    for i, (res, desc) in enumerate(result):
         print(u"  [{}] {} ({})".format(i, res, desc))
-    print(u"  [{}] Over The Air".format(len(result)))
+    print(u"  [{}] Over The Air ({})".format(len(result), get_upload_host(config)))
     print()
     while True:
         opt = raw_input('(number): ')
@@ -67,11 +63,11 @@ def discover_serial_ports():
         except ValueError:
             print(color('red', u"Invalid option: '{}'".format(opt)))
     if opt == len(result):
-        return None
-    return result[opt]
+        return 'OTA'
+    return result[opt][0]
 
 
-def run_platformio(*cmd):
+def run_platformio(*cmd, **kwargs):
     def mock_exit(return_code):
         raise SystemExit(return_code)
 
@@ -80,10 +76,13 @@ def run_platformio(*cmd):
     full_cmd = u' '.join(quote(x) for x in cmd)
     _LOGGER.info(u"Running:  %s", full_cmd)
     try:
-        import platformio.__main__
+        func = kwargs.get('main')
+        if func is None:
+            import platformio.__main__
+            func = platformio.__main__.main
         sys.argv = list(cmd)
         sys.exit = mock_exit
-        return platformio.__main__.main()
+        return func() or 0
     except KeyboardInterrupt:
         return 1
     except SystemExit as err:
@@ -96,29 +95,41 @@ def run_platformio(*cmd):
         sys.exit = orig_exit
 
 
-def run_miniterm(config, port):
-    from serial.tools import miniterm
+def run_miniterm(config, port, escape=False):
+    import serial
     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)
+    _LOGGER.info("Starting log output from %s with baud rate %s", port, baud_rate)
+
+    with serial.Serial(port, baudrate=baud_rate) as ser:
+        while True:
+            line = ser.readline()
+            time = datetime.now().time().strftime('[%H:%M:%S]')
+            message = time + line.decode('unicode-escape').replace('\r', '').replace('\n', '')
+            if escape:
+                message = message.replace('\033', '\\033').encode('ascii', 'replace')
+            print(message)
 
 
 def write_cpp(config):
     _LOGGER.info("Generating C++ source...")
+
+    add_task(core_to_code, config[CONF_ESPHOMEYAML])
     for domain in PRE_INITIALIZE:
+        if domain == CONF_ESPHOMEYAML:
+            continue
         if domain in config:
-            add_component_task(domain, config[domain])
+            add_task(get_component(domain).to_code, config[domain])
 
     # Clear queue
     get_variable(None)
     add(RawStatement(''))
 
-    for domain, conf in config.iteritems():
+    for domain, component, conf in iter_components(config):
         if domain in PRE_INITIALIZE:
             continue
-        add_component_task(domain, conf)
+        if not hasattr(component, 'to_code'):
+            continue
+        add_task(component.to_code, conf)
 
     # Clear queue
     get_variable(None)
@@ -127,15 +138,20 @@ def write_cpp(config):
 
     all_code = []
     for exp in _EXPRESSIONS:
-        if helpers.SIMPLIFY and isinstance(exp, AssignmentExpression) and exp.obj.usages == 0:
-            exp = exp.rhs
+        if core.SIMPLIFY:
+            if isinstance(exp, Expression) and not exp.required:
+                continue
+            if isinstance(exp, AssignmentExpression) and not exp.obj.required:
+                if not exp.has_side_effects():
+                    continue
+                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))
+    code_s = indent('\n'.join(line.rstrip() for line in all_code))
     cpp_path = os.path.join(get_base_path(config), 'src', 'main.cpp')
     writer.write_cpp(code_s, cpp_path)
     return 0
@@ -146,18 +162,40 @@ def compile_program(config):
     return run_platformio('platformio', 'run', '-d', get_base_path(config))
 
 
-def upload_program(config, args, port):
-    _LOGGER.info("Uploading binary...")
-    if port is not None:
-        return run_platformio('platformio', 'run', '-d', get_base_path(config),
-                              '-t', 'upload', '--upload-port', port)
-
+def get_upload_host(config):
     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'
+        host = config[CONF_WIFI][CONF_HOSTNAME] + config[CONF_WIFI][CONF_DOMAIN]
     else:
-        host = config[CONF_ESPHOMEYAML][CONF_NAME] + u'.local'
+        host = config[CONF_ESPHOMEYAML][CONF_NAME] + config[CONF_WIFI][CONF_DOMAIN]
+    return host
+
+
+def upload_using_esptool(config, port):
+    import esptool
+
+    name = get_name(config)
+    path = os.path.join(get_base_path(config), '.pioenvs', name, 'firmware.bin')
+    # pylint: disable=protected-access
+    return run_platformio('esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
+                          '--chip', 'esp8266', '--port', port, 'write_flash', '0x0',
+                          path, main=esptool._main)
+
+
+def upload_program(config, args, port):
+    _LOGGER.info("Uploading binary...")
+    if port != 'OTA':
+        if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266 and args.use_esptoolpy:
+            return upload_using_esptool(config, port)
+        return run_platformio('platformio', 'run', '-d', get_base_path(config),
+                              '-t', 'upload', '--upload-port', port)
+
+    if 'ota' not in config:
+        _LOGGER.error("No serial port found and OTA not enabled. Can't upload!")
+        return -1
+
+    host = get_upload_host(config)
 
     from esphomeyaml.components import ota
     from esphomeyaml import espota
@@ -173,11 +211,12 @@ def upload_program(config, args, port):
     return espota.main(espota_args)
 
 
-def show_logs(config, args, port):
-    if port is not None and port != 'OTA':
-        run_miniterm(config, port)
+def show_logs(config, args, port, escape=False):
+    if port != 'OTA':
+        run_miniterm(config, port, escape=escape)
         return 0
-    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id,
+                          escape=escape)
 
 
 def clean_mqtt(config, args):
@@ -210,13 +249,98 @@ def setup_log():
         pass
 
 
-def main():
-    global CONFIG_PATH
+def command_wizard(args):
+    return wizard.wizard(args.configuration)
 
-    setup_log()
 
+def command_config(args, config):
+    print(yaml_util.dump(config))
+    return 0
+
+
+def command_compile(args, config):
+    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
+
+
+def command_upload(args, config):
+    port = args.upload_port or choose_serial_port(config)
+    exit_code = upload_program(config, args, port)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully uploaded program.")
+    return 0
+
+
+def command_logs(args, config):
+    port = args.serial_port or choose_serial_port(config)
+    return show_logs(config, args, port, escape=args.escape)
+
+
+def command_run(args, config):
+    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.")
+    port = args.upload_port or choose_serial_port(config)
+    exit_code = upload_program(config, args, port)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully uploaded program.")
+    if args.no_logs:
+        return 0
+    return show_logs(config, args, port, escape=args.escape)
+
+
+def command_clean_mqtt(args, config):
+    return clean_mqtt(config, args)
+
+
+def command_mqtt_fingerprint(args, config):
+    return mqtt.get_fingerprint(config)
+
+
+def command_version(args):
+    print(u"Version: {}".format(const.__version__))
+    return 0
+
+
+def command_dashboard(args):
+    from esphomeyaml.dashboard import dashboard
+
+    return dashboard.start_web_server(args)
+
+
+PRE_CONFIG_ACTIONS = {
+    'wizard': command_wizard,
+    'version': command_version,
+    'dashboard': command_dashboard
+}
+
+POST_CONFIG_ACTIONS = {
+    'config': command_config,
+    'compile': command_compile,
+    'upload': command_upload,
+    'logs': command_logs,
+    'run': command_run,
+    'clean-mqtt': command_clean_mqtt,
+    'mqtt-fingerprint': command_mqtt_fingerprint,
+}
+
+
+def parse_args(argv):
     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
     subparsers.add_parser('config', help='Validate the configuration and spit it out.')
@@ -228,6 +352,9 @@ def main():
     parser_upload.add_argument('--upload-port', help="Manually specify the upload port to use. "
                                                      "For example /dev/cu.SLAB_USBtoUART.")
     parser_upload.add_argument('--host-port', help="Specify the host port.", type=int)
+    parser_upload.add_argument('--use-esptoolpy',
+                               help="Use esptool.py for the uploading (only for ESP8266)",
+                               action='store_true')
 
     parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
                                                      'and show all MQTT logs.')
@@ -237,6 +364,8 @@ def main():
     parser_logs.add_argument('--client-id', help='Manually set the client id.')
     parser_logs.add_argument('--serial-port', help="Manually specify a serial port to use"
                                                    "For example /dev/cu.SLAB_USBtoUART.")
+    parser_logs.add_argument('--escape', help="Escape ANSI color codes for running in dashboard",
+                             action='store_true')
 
     parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
                                                    'upload it, and start MQTT logs.')
@@ -249,6 +378,11 @@ def main():
     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_run.add_argument('--escape', help="Escape ANSI color codes for running in dashboard",
+                            action='store_true')
+    parser_run.add_argument('--use-esptoolpy',
+                            help="Use esptool.py for the uploading (only for ESP8266)",
+                            action='store_true')
 
     parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
                                                             "retain messages.")
@@ -260,59 +394,53 @@ def main():
     subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
                                          "you through setting up esphomeyaml.")
 
-    args = parser.parse_args()
+    subparsers.add_parser('mqtt-fingerprint', help="Get the SSL fingerprint from a MQTT broker.")
 
-    if args.command == 'wizard':
-        return wizard.wizard(args.configuration)
+    subparsers.add_parser('version', help="Print the esphomeyaml version and exit.")
 
-    CONFIG_PATH = args.configuration
-    config = read_config(CONFIG_PATH)
+    dashboard = subparsers.add_parser('dashboard',
+                                      help="Create a simple webserver for a dashboard.")
+    dashboard.add_argument("--port", help="The HTTP port to open connections on.", type=int,
+                           default=6052)
+
+    return parser.parse_args(argv[1:])
+
+
+def run_esphomeyaml(argv):
+    setup_log()
+    args = parse_args(argv)
+    if args.command in PRE_CONFIG_ACTIONS:
+        try:
+            return PRE_CONFIG_ACTIONS[args.command](args)
+        except ESPHomeYAMLError as e:
+            _LOGGER.error(e)
+            return 1
+
+    core.CONFIG_PATH = args.configuration
+
+    config = read_config(core.CONFIG_PATH)
     if config is None:
         return 1
 
-    if args.command == 'config':
-        print(yaml_util.dump(config))
-        return 0
-    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 = args.upload_port or 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 = args.serial_port or 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 0
-        port = args.upload_port or 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)
+    if args.command in POST_CONFIG_ACTIONS:
+        try:
+            return POST_CONFIG_ACTIONS[args.command](args, config)
+        except ESPHomeYAMLError as e:
+            _LOGGER.error(e)
+            return 1
     print(u"Unknown command {}".format(args.command))
     return 1
 
 
+def main():
+    try:
+        return run_esphomeyaml(sys.argv)
+    except ESPHomeYAMLError as e:
+        _LOGGER.error(e)
+        return 1
+    except KeyboardInterrupt:
+        return 1
+
+
 if __name__ == "__main__":
     sys.exit(main())

esphomeyaml/automation.py

@@ -0,0 +1,297 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import cover, fan
+from esphomeyaml.const import CONF_ACTION_ID, CONF_AND, CONF_AUTOMATION_ID, CONF_BLUE, \
+    CONF_BRIGHTNESS, CONF_CONDITION_ID, CONF_DELAY, CONF_EFFECT, CONF_FLASH_LENGTH, CONF_GREEN, \
+    CONF_ID, CONF_IF, CONF_LAMBDA, CONF_OR, CONF_OSCILLATING, CONF_PAYLOAD, \
+    CONF_QOS, CONF_RANGE, CONF_RED, CONF_RETAIN, CONF_SPEED, CONF_THEN, CONF_TOPIC, \
+    CONF_TRANSITION_LENGTH, CONF_TRIGGER_ID, CONF_WHITE, CONF_ABOVE, CONF_BELOW
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, TemplateArguments, add, \
+    bool_, esphomelib_ns, float_, get_variable, process_lambda, std_string, templatable, uint32, \
+    uint8
+
+CONF_MQTT_PUBLISH = 'mqtt.publish'
+CONF_LIGHT_TOGGLE = 'light.toggle'
+CONF_LIGHT_TURN_OFF = 'light.turn_off'
+CONF_LIGHT_TURN_ON = 'light.turn_on'
+CONF_SWITCH_TOGGLE = 'switch.toggle'
+CONF_SWITCH_TURN_OFF = 'switch.turn_off'
+CONF_SWITCH_TURN_ON = 'switch.turn_on'
+CONF_COVER_OPEN = 'cover.open'
+CONF_COVER_CLOSE = 'cover.close'
+CONF_COVER_STOP = 'cover.stop'
+CONF_FAN_TOGGLE = 'fan.toggle'
+CONF_FAN_TURN_OFF = 'fan.turn_off'
+CONF_FAN_TURN_ON = 'fan.turn_on'
+
+ACTION_KEYS = [CONF_DELAY, CONF_MQTT_PUBLISH, CONF_LIGHT_TOGGLE, CONF_LIGHT_TURN_OFF,
+               CONF_LIGHT_TURN_ON, CONF_SWITCH_TOGGLE, CONF_SWITCH_TURN_OFF, CONF_SWITCH_TURN_ON,
+               CONF_LAMBDA, CONF_COVER_OPEN, CONF_COVER_CLOSE, CONF_COVER_STOP, CONF_FAN_TOGGLE,
+               CONF_FAN_TURN_OFF, CONF_FAN_TURN_ON]
+
+ACTIONS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
+    cv.GenerateID('action', CONF_ACTION_ID): cv.register_variable_id,
+    vol.Optional(CONF_DELAY): cv.templatable(cv.positive_time_period_milliseconds),
+    vol.Optional(CONF_MQTT_PUBLISH): vol.Schema({
+        vol.Required(CONF_TOPIC): cv.templatable(cv.publish_topic),
+        vol.Required(CONF_PAYLOAD): cv.templatable(cv.mqtt_payload),
+        vol.Optional(CONF_QOS): cv.templatable(cv.mqtt_qos),
+        vol.Optional(CONF_RETAIN): cv.templatable(cv.boolean),
+    }),
+    vol.Optional(CONF_LIGHT_TOGGLE): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+        vol.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
+    }),
+    vol.Optional(CONF_LIGHT_TURN_OFF): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+        vol.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
+    }),
+    vol.Optional(CONF_LIGHT_TURN_ON): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+        vol.Exclusive(CONF_TRANSITION_LENGTH, 'transformer'):
+            cv.templatable(cv.positive_time_period_milliseconds),
+        vol.Exclusive(CONF_FLASH_LENGTH, 'transformer'):
+            cv.templatable(cv.positive_time_period_milliseconds),
+        vol.Optional(CONF_BRIGHTNESS): cv.templatable(cv.percentage),
+        vol.Optional(CONF_RED): cv.templatable(cv.percentage),
+        vol.Optional(CONF_GREEN): cv.templatable(cv.percentage),
+        vol.Optional(CONF_BLUE): cv.templatable(cv.percentage),
+        vol.Optional(CONF_WHITE): cv.templatable(cv.percentage),
+        vol.Optional(CONF_EFFECT): cv.templatable(cv.string),
+    }),
+    vol.Optional(CONF_SWITCH_TOGGLE): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_SWITCH_TURN_OFF): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_SWITCH_TURN_ON): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_COVER_OPEN): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_COVER_CLOSE): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_COVER_STOP): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_COVER_OPEN): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_COVER_CLOSE): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_COVER_STOP): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_FAN_TOGGLE): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_FAN_TURN_OFF): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+    }),
+    vol.Optional(CONF_FAN_TURN_ON): vol.Schema({
+        vol.Required(CONF_ID): cv.variable_id,
+        vol.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean),
+        vol.Optional(CONF_SPEED): cv.templatable(fan.validate_fan_speed),
+    }),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+}, cv.has_at_exactly_one_key(*ACTION_KEYS))])
+
+# pylint: disable=invalid-name
+DelayAction = esphomelib_ns.DelayAction
+LambdaAction = esphomelib_ns.LambdaAction
+Automation = esphomelib_ns.Automation
+
+
+def validate_recursive_condition(value):
+    return CONDITIONS_SCHEMA(value)
+
+
+CONDITION_KEYS = [CONF_AND, CONF_OR, CONF_RANGE, CONF_LAMBDA]
+
+CONDITIONS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
+    cv.GenerateID('condition', CONF_CONDITION_ID): cv.register_variable_id,
+    vol.Optional(CONF_AND): validate_recursive_condition,
+    vol.Optional(CONF_OR): validate_recursive_condition,
+    vol.Optional(CONF_RANGE): vol.All(vol.Schema({
+        vol.Optional(CONF_ABOVE): vol.Coerce(float),
+        vol.Optional(CONF_BELOW): vol.Coerce(float),
+    }), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+}), cv.has_at_exactly_one_key(*CONDITION_KEYS)])
+
+# pylint: disable=invalid-name
+AndCondition = esphomelib_ns.AndCondition
+OrCondition = esphomelib_ns.OrCondition
+RangeCondition = esphomelib_ns.RangeCondition
+LambdaCondition = esphomelib_ns.LambdaCondition
+
+AUTOMATION_SCHEMA = vol.Schema({
+    cv.GenerateID('trigger', CONF_TRIGGER_ID): cv.register_variable_id,
+    cv.GenerateID('automation', CONF_AUTOMATION_ID): cv.register_variable_id,
+    vol.Optional(CONF_IF): CONDITIONS_SCHEMA,
+    vol.Required(CONF_THEN): ACTIONS_SCHEMA,
+})
+
+
+def build_condition(config, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    if CONF_AND in config:
+        return AndCondition.new(template_arg, build_conditions(config[CONF_AND], template_arg))
+    if CONF_OR in config:
+        return OrCondition.new(template_arg, build_conditions(config[CONF_OR], template_arg))
+    if CONF_LAMBDA in config:
+        return LambdaCondition.new(template_arg,
+                                   process_lambda(config[CONF_LAMBDA], [(arg_type, 'x')]))
+    if CONF_RANGE in config:
+        conf = config[CONF_RANGE]
+        rhs = RangeCondition.new(template_arg)
+        condition = Pvariable(RangeCondition.template(template_arg), config[CONF_CONDITION_ID], rhs)
+        if CONF_ABOVE in conf:
+            condition.set_min(templatable(conf[CONF_ABOVE], arg_type, float_))
+        if CONF_BELOW in conf:
+            condition.set_max(templatable(conf[CONF_BELOW], arg_type, float_))
+        return condition
+    raise ESPHomeYAMLError(u"Unsupported condition {}".format(config))
+
+
+def build_conditions(config, arg_type):
+    return ArrayInitializer(*[build_condition(x, arg_type) for x in config])
+
+
+def build_action(config, arg_type):
+    from esphomeyaml.components import light, mqtt, switch
+
+    template_arg = TemplateArguments(arg_type)
+    if CONF_DELAY in config:
+        rhs = App.register_component(DelayAction.new(template_arg))
+        action = Pvariable(DelayAction.template(template_arg), config[CONF_ACTION_ID], rhs)
+        add(action.set_delay(templatable(config[CONF_DELAY], arg_type, uint32)))
+        return action
+    elif CONF_LAMBDA in config:
+        rhs = LambdaAction.new(template_arg, process_lambda(config[CONF_LAMBDA], [(arg_type, 'x')]))
+        return Pvariable(LambdaAction.template(template_arg), config[CONF_ACTION_ID], rhs)
+    elif CONF_MQTT_PUBLISH in config:
+        conf = config[CONF_MQTT_PUBLISH]
+        rhs = App.Pget_mqtt_client().Pmake_publish_action()
+        action = Pvariable(mqtt.MQTTPublishAction.template(template_arg), config[CONF_ACTION_ID],
+                           rhs)
+        add(action.set_topic(templatable(conf[CONF_TOPIC], arg_type, std_string)))
+        add(action.set_payload(templatable(conf[CONF_PAYLOAD], arg_type, std_string)))
+        if CONF_QOS in conf:
+            add(action.set_qos(templatable(conf[CONF_QOS], arg_type, uint8)))
+        if CONF_RETAIN in conf:
+            add(action.set_retain(templatable(conf[CONF_RETAIN], arg_type, bool_)))
+        return action
+    elif CONF_LIGHT_TOGGLE in config:
+        conf = config[CONF_LIGHT_TOGGLE]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_toggle_action(template_arg)
+        action = Pvariable(light.ToggleAction.template(template_arg), config[CONF_ACTION_ID], rhs)
+        if CONF_TRANSITION_LENGTH in conf:
+            add(action.set_transition_length(
+                templatable(conf[CONF_TRANSITION_LENGTH], arg_type, uint32)
+            ))
+        return action
+    elif CONF_LIGHT_TURN_OFF in config:
+        conf = config[CONF_LIGHT_TURN_OFF]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_turn_off_action(template_arg)
+        action = Pvariable(light.TurnOffAction.template(template_arg), config[CONF_ACTION_ID], rhs)
+        if CONF_TRANSITION_LENGTH in conf:
+            add(action.set_transition_length(
+                templatable(conf[CONF_TRANSITION_LENGTH], arg_type, uint32)
+            ))
+        return action
+    elif CONF_LIGHT_TURN_ON in config:
+        conf = config[CONF_LIGHT_TURN_ON]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_turn_on_action(template_arg)
+        action = Pvariable(light.TurnOnAction.template(template_arg), config[CONF_ACTION_ID], rhs)
+        if CONF_TRANSITION_LENGTH in conf:
+            add(action.set_transition_length(
+                templatable(conf[CONF_TRANSITION_LENGTH], arg_type, uint32)
+            ))
+        if CONF_FLASH_LENGTH in conf:
+            add(action.set_flash_length(templatable(conf[CONF_FLASH_LENGTH], arg_type, uint32)))
+        if CONF_BRIGHTNESS in conf:
+            add(action.set_brightness(templatable(conf[CONF_BRIGHTNESS], arg_type, float_)))
+        if CONF_RED in conf:
+            add(action.set_red(templatable(conf[CONF_RED], arg_type, float_)))
+        if CONF_GREEN in conf:
+            add(action.set_green(templatable(conf[CONF_GREEN], arg_type, float_)))
+        if CONF_BLUE in conf:
+            add(action.set_blue(templatable(conf[CONF_BLUE], arg_type, float_)))
+        if CONF_WHITE in conf:
+            add(action.set_white(templatable(conf[CONF_WHITE], arg_type, float_)))
+        if CONF_EFFECT in conf:
+            add(action.set_effect(templatable(conf[CONF_EFFECT], arg_type, std_string)))
+        return action
+    elif CONF_SWITCH_TOGGLE in config:
+        conf = config[CONF_SWITCH_TOGGLE]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_toggle_action(template_arg)
+        return Pvariable(switch.ToggleAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_SWITCH_TURN_OFF in config:
+        conf = config[CONF_SWITCH_TURN_OFF]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_turn_off_action(template_arg)
+        return Pvariable(switch.TurnOffAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_SWITCH_TURN_ON in config:
+        conf = config[CONF_SWITCH_TURN_ON]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_turn_on_action(template_arg)
+        return Pvariable(switch.TurnOnAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_COVER_OPEN in config:
+        conf = config[CONF_COVER_OPEN]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_open_action(template_arg)
+        return Pvariable(cover.OpenAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_COVER_CLOSE in config:
+        conf = config[CONF_COVER_CLOSE]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_close_action(template_arg)
+        return Pvariable(cover.CloseAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_COVER_STOP in config:
+        conf = config[CONF_COVER_STOP]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_stop_action(template_arg)
+        return Pvariable(cover.StopAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_FAN_TOGGLE in config:
+        conf = config[CONF_FAN_TOGGLE]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_toggle_action(template_arg)
+        return Pvariable(fan.ToggleAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_FAN_TURN_OFF in config:
+        conf = config[CONF_FAN_TURN_OFF]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_turn_off_action(template_arg)
+        return Pvariable(fan.TurnOffAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+    elif CONF_FAN_TURN_ON in config:
+        conf = config[CONF_FAN_TURN_ON]
+        var = get_variable(conf[CONF_ID])
+        rhs = var.make_turn_on_action(template_arg)
+        action = Pvariable(fan.TurnOnAction.template(arg_type), config[CONF_ACTION_ID], rhs)
+        if CONF_OSCILLATING in config:
+            add(action.set_oscillating(templatable(conf[CONF_OSCILLATING], arg_type, bool_)))
+        if CONF_SPEED in config:
+            add(action.set_speed(templatable(conf[CONF_SPEED], arg_type, fan.FanSpeed)))
+        return action
+    raise ESPHomeYAMLError(u"Unsupported action {}".format(config))
+
+
+def build_actions(config, arg_type):
+    return ArrayInitializer(*[build_action(x, arg_type) for x in config])
+
+
+def build_automation(trigger, arg_type, config):
+    rhs = App.make_automation(trigger)
+    obj = Pvariable(Automation.template(arg_type), config[CONF_AUTOMATION_ID], rhs)
+    if CONF_IF in config:
+        add(obj.add_conditions(build_conditions(config[CONF_IF], arg_type)))
+    add(obj.add_actions(build_actions(config[CONF_THEN], arg_type)))

esphomeyaml/components/ads1115.py

@@ -1,28 +1,21 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_RATE
-from esphomeyaml.helpers import App, Pvariable, RawExpression, add, HexIntLiteral
+from esphomeyaml.helpers import App, Pvariable
 
 DEPENDENCIES = ['i2c']
 
-ADS1115_COMPONENT_CLASS = 'sensor::ADS1115Component'
+ADS1115Component = sensor.sensor_ns.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',
-}
+RATE_REMOVE_MESSAGE = """The rate option has been removed in 1.5.0 and is no longer required."""
 
 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()))),
+
+    vol.Optional(CONF_RATE): cv.invalid(RATE_REMOVE_MESSAGE)
 })
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [ADS1115_SCHEMA])
@@ -30,8 +23,8 @@ 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]])))
+        rhs = App.make_ads1115_component(conf[CONF_ADDRESS])
+        Pvariable(ADS1115Component, conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphomeyaml/components/binary_sensor/__init__.py

@@ -1,12 +1,11 @@
 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,
-})
+from esphomeyaml import automation
+from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_ID, CONF_INVERTED, CONF_MAX_LENGTH, \
+    CONF_MIN_LENGTH, CONF_MQTT_ID, CONF_ON_CLICK, CONF_ON_DOUBLE_CLICK, CONF_ON_PRESS, \
+    CONF_ON_RELEASE, CONF_TRIGGER_ID
+from esphomeyaml.helpers import App, NoArg, Pvariable, add, esphomelib_ns, setup_mqtt_component
 
 DEVICE_CLASSES = [
     '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
@@ -15,15 +14,82 @@ DEVICE_CLASSES = [
     'sound', 'vibration', 'window'
 ]
 
-DEVICE_CLASSES_MSG = "Unknown device class. Must be one of {}".format(', '.join(DEVICE_CLASSES))
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
-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)),
+})
+
+binary_sensor_ns = esphomelib_ns.namespace('binary_sensor')
+PressTrigger = binary_sensor_ns.PressTrigger
+ReleaseTrigger = binary_sensor_ns.ReleaseTrigger
+ClickTrigger = binary_sensor_ns.ClickTrigger
+DoubleClickTrigger = binary_sensor_ns.DoubleClickTrigger
+BinarySensor = binary_sensor_ns.BinarySensor
+MQTTBinarySensorComponent = binary_sensor_ns.MQTTBinarySensorComponent
+
+BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID('mqtt_binary_sensor', CONF_MQTT_ID): cv.register_variable_id,
+    cv.GenerateID('binary_sensor'): cv.register_variable_id,
+    vol.Optional(CONF_INVERTED): cv.boolean,
+    vol.Optional(CONF_DEVICE_CLASS): vol.All(vol.Lower, cv.one_of(*DEVICE_CLASSES)),
+    vol.Optional(CONF_ON_PRESS): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA]),
+    vol.Optional(CONF_ON_RELEASE): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA]),
+    vol.Optional(CONF_ON_CLICK): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA.extend({
+        vol.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
+        vol.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
+    })]),
+    vol.Optional(CONF_ON_DOUBLE_CLICK):
+        vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA.extend({
+            vol.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
+            vol.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
+        })]),
 })
 
 
-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)
+def setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config):
+    if CONF_DEVICE_CLASS in config:
+        add(binary_sensor_var.set_device_class(config[CONF_DEVICE_CLASS]))
+    if CONF_INVERTED in config:
+        add(binary_sensor_var.set_inverted(config[CONF_INVERTED]))
+
+    for conf in config.get(CONF_ON_PRESS, []):
+        rhs = binary_sensor_var.make_press_trigger()
+        trigger = Pvariable(PressTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, conf)
+
+    for conf in config.get(CONF_ON_RELEASE, []):
+        rhs = binary_sensor_var.make_release_trigger()
+        trigger = Pvariable(ReleaseTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, conf)
+
+    for conf in config.get(CONF_ON_CLICK, []):
+        rhs = binary_sensor_var.make_click_trigger(conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH])
+        trigger = Pvariable(ClickTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, conf)
+
+    for conf in config.get(CONF_ON_DOUBLE_CLICK, []):
+        rhs = binary_sensor_var.make_double_click_trigger(conf[CONF_MIN_LENGTH],
+                                                          conf[CONF_MAX_LENGTH])
+        trigger = Pvariable(DoubleClickTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, conf)
+
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_binary_sensor(binary_sensor_obj, mqtt_obj, config):
+    binary_sensor_var = Pvariable(BinarySensor, config[CONF_ID], binary_sensor_obj,
+                                  has_side_effects=False)
+    mqtt_var = Pvariable(MQTTBinarySensorComponent, config[CONF_MQTT_ID], mqtt_obj,
+                         has_side_effects=False)
+    setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config)
+
+
+def register_binary_sensor(var, config):
+    binary_sensor_var = Pvariable(BinarySensor, config[CONF_ID], var,
+                                  has_side_effects=True)
+    rhs = App.register_binary_sensor(binary_sensor_var)
+    mqtt_var = Pvariable(MQTTBinarySensorComponent, config[CONF_MQTT_ID], rhs,
+                         has_side_effects=True)
+    setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/esp32_ble.py

@@ -0,0 +1,43 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.esp32_ble import ESP32BLETracker
+from esphomeyaml.const import CONF_MAC_ADDRESS, CONF_NAME, ESP_PLATFORM_ESP32
+from esphomeyaml.core import HexInt, MACAddress
+from esphomeyaml.helpers import ArrayInitializer, get_variable
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+DEPENDENCIES = ['esp32_ble']
+
+
+def validate_mac(value):
+    value = cv.string_strict(value)
+    parts = value.split(':')
+    if len(parts) != 6:
+        raise vol.Invalid("MAC Address must consist of 6 : (colon) separated parts")
+    parts_int = []
+    if any(len(part) != 2 for part in parts):
+        raise vol.Invalid("MAC Address must be format XX:XX:XX:XX:XX:XX")
+    for part in parts:
+        try:
+            parts_int.append(int(part, 16))
+        except ValueError:
+            raise vol.Invalid("MAC Address parts must be hexadecimal values from 00 to FF")
+
+    return MACAddress(*parts_int)
+
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_MAC_ADDRESS): validate_mac,
+}).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    hub = get_variable(None, type=ESP32BLETracker)
+    addr = [HexInt(i) for i in config[CONF_MAC_ADDRESS].parts]
+    rhs = hub.make_device(config[CONF_NAME], ArrayInitializer(*addr, multiline=False))
+    binary_sensor.register_binary_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_TRACKER'

esphomeyaml/components/binary_sensor/esp32_touch.py

@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.esp32_touch import ESP32TouchComponent
+from esphomeyaml.const import CONF_NAME, CONF_PIN, CONF_THRESHOLD, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import get_variable, global_ns
+from esphomeyaml.pins import validate_gpio_pin
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+DEPENDENCIES = ['esp32_touch']
+
+TOUCH_PADS = {
+    4: global_ns.TOUCH_PAD_NUM0,
+    0: global_ns.TOUCH_PAD_NUM1,
+    2: global_ns.TOUCH_PAD_NUM2,
+    15: global_ns.TOUCH_PAD_NUM3,
+    13: global_ns.TOUCH_PAD_NUM4,
+    12: global_ns.TOUCH_PAD_NUM5,
+    14: global_ns.TOUCH_PAD_NUM6,
+    27: global_ns.TOUCH_PAD_NUM7,
+    33: global_ns.TOUCH_PAD_NUM8,
+    32: global_ns.TOUCH_PAD_NUM9,
+}
+
+
+def validate_touch_pad(value):
+    value = validate_gpio_pin(value)
+    if value not in TOUCH_PADS:
+        raise vol.Invalid("Pin {} does not support touch pads.".format(value))
+    return value
+
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PIN): validate_touch_pad,
+    vol.Required(CONF_THRESHOLD): cv.uint16_t,
+}).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    hub = get_variable(None, type=ESP32TouchComponent)
+    touch_pad = TOUCH_PADS[config[CONF_PIN]]
+    rhs = hub.make_touch_pad(config[CONF_NAME], touch_pad, config[CONF_THRESHOLD])
+    binary_sensor.register_binary_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/gpio.py

@@ -3,19 +3,22 @@ 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
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, gpio_input_pin_expression, variable, Application
 
 PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('gpio_binary_sensor'): cv.register_variable_id,
+    cv.GenerateID('gpio_binary_sensor', CONF_MAKE_ID): cv.register_variable_id,
     vol.Required(CONF_PIN): pins.GPIO_INPUT_PIN_SCHEMA
-}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+}).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema)
+
+MakeGPIOBinarySensor = Application.MakeGPIOBinarySensor
 
 
 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)
+    rhs = App.make_gpio_binary_sensor(config[CONF_NAME],
+                                      gpio_input_pin_expression(config[CONF_PIN]))
+    gpio = variable(MakeGPIOBinarySensor, config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(gpio.Pgpio, gpio.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/status.py

@@ -1,14 +1,21 @@
 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
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable
+
+DEPENDENCIES = ['mqtt']
 
 PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('status_binary_sensor'): cv.register_variable_id,
-}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+    cv.GenerateID('status_binary_sensor', CONF_MAKE_ID): cv.register_variable_id,
+}).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema)
+
+MakeStatusBinarySensor = Application.MakeStatusBinarySensor
 
 
 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)
+    status = variable(MakeStatusBinarySensor, config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(status.Pstatus, status.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/template.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, process_lambda, variable
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('template_binary_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+}).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema)
+
+MakeTemplateBinarySensor = Application.MakeTemplateBinarySensor
+
+
+def to_code(config):
+    template_ = process_lambda(config[CONF_LAMBDA], [])
+    rhs = App.make_template_binary_sensor(config[CONF_NAME], template_)
+    make = variable(MakeTemplateBinarySensor, config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(make.Ptemplate_, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_BINARY_SENSOR'

esphomeyaml/components/cover/__init__.py

@@ -0,0 +1,36 @@
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_MQTT_ID
+from esphomeyaml.helpers import Pvariable, esphomelib_ns, setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+COVER_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID('cover'): cv.register_variable_id,
+    cv.GenerateID('mqtt_cover', CONF_MQTT_ID): cv.register_variable_id,
+})
+
+cover_ns = esphomelib_ns.namespace('cover')
+Cover = cover_ns.Cover
+MQTTCoverComponent = cover_ns.MQTTCoverComponent
+CoverState = cover_ns.CoverState
+COVER_OPEN = cover_ns.COVER_OPEN
+COVER_CLOSED = cover_ns.COVER_CLOSED
+OpenAction = cover_ns.OpenAction
+CloseAction = cover_ns.CloseAction
+StopAction = cover_ns.StopAction
+
+
+def setup_cover_core_(cover_var, mqtt_var, config):
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_cover(cover_obj, mqtt_obj, config):
+    cover_var = Pvariable(Cover, config[CONF_ID], cover_obj, has_side_effects=False)
+    mqtt_var = Pvariable(MQTTCoverComponent, config[CONF_MQTT_ID], mqtt_obj,
+                         has_side_effects=False)
+    setup_cover_core_(cover_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_COVER'

esphomeyaml/components/cover/template.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import automation
+from esphomeyaml.components import cover
+from esphomeyaml.const import CONF_CLOSE_ACTION, CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, \
+    CONF_OPEN_ACTION, CONF_STOP_ACTION, CONF_OPTIMISTIC
+from esphomeyaml.helpers import App, Application, NoArg, add, process_lambda, variable
+
+PLATFORM_SCHEMA = vol.All(cover.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('template_cover', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_OPEN_ACTION): automation.ACTIONS_SCHEMA,
+    vol.Optional(CONF_CLOSE_ACTION): automation.ACTIONS_SCHEMA,
+    vol.Optional(CONF_STOP_ACTION): automation.ACTIONS_SCHEMA,
+}).extend(cover.COVER_SCHEMA.schema), cv.has_at_exactly_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
+
+MakeTemplateCover = Application.MakeTemplateCover
+
+
+def to_code(config):
+    rhs = App.make_template_cover(config[CONF_NAME])
+    make = variable(MakeTemplateCover, config[CONF_MAKE_ID], rhs)
+
+    if CONF_LAMBDA in config:
+        template_ = process_lambda(config[CONF_LAMBDA], [])
+        add(make.Ptemplate.set_state_lambda(template_))
+    if CONF_OPEN_ACTION in config:
+        actions = automation.build_actions(config[CONF_OPEN_ACTION], NoArg)
+        add(make.Ptemplate_.add_open_actions(actions))
+    if CONF_CLOSE_ACTION in config:
+        actions = automation.build_actions(config[CONF_CLOSE_ACTION], NoArg)
+        add(make.Ptemplate_.add_close_actions(actions))
+    if CONF_STOP_ACTION in config:
+        actions = automation.build_actions(config[CONF_STOP_ACTION], NoArg)
+        add(make.Ptemplate_.add_stop_actions(actions))
+    if CONF_OPTIMISTIC in config:
+        add(make.Ptemplate_.set_optimistic(config[CONF_OPTIMISTIC]))
+
+    cover.setup_cover(make.Ptemplate_, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_COVER'

esphomeyaml/components/dallas.py

@@ -2,19 +2,23 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
+from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
 from esphomeyaml.helpers import App, Pvariable
 
-DALLAS_COMPONENT_CLASS = 'sensor::DallasComponent'
+DallasComponent = sensor.sensor_ns.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,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
 })])
 
 
 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)
+        Pvariable(DallasComponent, conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphomeyaml/components/debug.py

@@ -0,0 +1,14 @@
+import voluptuous as vol
+
+from esphomeyaml.helpers import App, add
+
+DEPENDENCIES = ['logger']
+
+CONFIG_SCHEMA = vol.Schema({})
+
+
+def to_code(config):
+    add(App.make_debug_component())
+
+
+BUILD_FLAGS = '-DUSE_DEBUG_COMPONENT'

esphomeyaml/components/deep_sleep.py

@@ -0,0 +1,43 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv, pins
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_RUN_CYCLES, CONF_RUN_DURATION, \
+    CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
+from esphomeyaml.helpers import App, Pvariable, add, gpio_input_pin_expression, esphomelib_ns
+
+
+def validate_pin_number(value):
+    valid_pins = [0, 2, 4, 12, 13, 14, 15, 25, 26, 27, 32, 39]
+    if value[CONF_NUMBER] not in valid_pins:
+        raise vol.Invalid(u"Only pins {} support wakeup"
+                          u"".format(', '.join(str(x) for x in valid_pins)))
+    return value
+
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID('deep_sleep'): cv.register_variable_id,
+    vol.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+                                           validate_pin_number),
+    vol.Optional(CONF_RUN_CYCLES): cv.positive_int,
+    vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
+})
+
+DeepSleepComponent = esphomelib_ns.DeepSleepComponent
+
+
+def to_code(config):
+    rhs = App.make_deep_sleep_component()
+    deep_sleep = Pvariable(DeepSleepComponent, config[CONF_ID], rhs)
+    if CONF_SLEEP_DURATION in config:
+        add(deep_sleep.set_sleep_duration(config[CONF_SLEEP_DURATION]))
+    if CONF_WAKEUP_PIN in config:
+        pin = gpio_input_pin_expression(config[CONF_WAKEUP_PIN])
+        add(deep_sleep.set_wakeup_pin(pin))
+    if CONF_RUN_CYCLES in config:
+        add(deep_sleep.set_run_cycles(config[CONF_RUN_CYCLES]))
+    if CONF_RUN_DURATION in config:
+        add(deep_sleep.set_run_duration(config[CONF_RUN_DURATION]))
+
+
+BUILD_FLAGS = '-DUSE_DEEP_SLEEP'

esphomeyaml/components/esp32_ble.py

@@ -0,0 +1,24 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID('esp32_ble'): cv.register_variable_id,
+    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds,
+})
+
+ESP32BLETracker = esphomelib_ns.ESP32BLETracker
+
+
+def to_code(config):
+    rhs = App.make_esp32_ble_tracker()
+    ble = Pvariable(ESP32BLETracker, config[CONF_ID], rhs)
+    if CONF_SCAN_INTERVAL in config:
+        add(ble.set_scan_interval(config[CONF_SCAN_INTERVAL]))
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_TRACKER'

esphomeyaml/components/esp32_touch.py

@@ -0,0 +1,84 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_ID, CONF_SETUP_MODE, CONF_IIR_FILTER, \
+    CONF_SLEEP_DURATION, CONF_MEASUREMENT_DURATION, CONF_LOW_VOLTAGE_REFERENCE, \
+    CONF_HIGH_VOLTAGE_REFERENCE, CONF_VOLTAGE_ATTENUATION, ESP_PLATFORM_ESP32
+from esphomeyaml.core import TimePeriod
+from esphomeyaml.helpers import App, Pvariable, add, global_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+
+def validate_voltage(values):
+    def validator(value):
+        if isinstance(value, float) and value.is_integer():
+            value = int(value)
+        value = cv.string(value)
+        if not value.endswith('V'):
+            value += 'V'
+        return cv.one_of(*values)(value)
+    return validator
+
+
+LOW_VOLTAGE_REFERENCE = {
+    '0.5V': global_ns.TOUCH_LVOLT_0V5,
+    '0.6V': global_ns.TOUCH_LVOLT_0V6,
+    '0.7V': global_ns.TOUCH_LVOLT_0V7,
+    '0.8V': global_ns.TOUCH_LVOLT_0V8,
+}
+HIGH_VOLTAGE_REFERENCE = {
+    '2.4V': global_ns.TOUCH_HVOLT_2V4,
+    '2.5V': global_ns.TOUCH_HVOLT_2V5,
+    '2.6V': global_ns.TOUCH_HVOLT_2V6,
+    '2.7V': global_ns.TOUCH_HVOLT_2V7,
+}
+VOLTAGE_ATTENUATION = {
+    '1.5V': global_ns.TOUCH_HVOLT_ATTEN_1V5,
+    '1V': global_ns.TOUCH_HVOLT_ATTEN_1V,
+    '0.5V': global_ns.TOUCH_HVOLT_ATTEN_0V5,
+    '0V': global_ns.TOUCH_HVOLT_ATTEN_0V,
+}
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID('esp32_ble'): cv.register_variable_id,
+    vol.Optional(CONF_SETUP_MODE): cv.boolean,
+    vol.Optional(CONF_IIR_FILTER): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_SLEEP_DURATION):
+        vol.All(cv.positive_time_period, vol.Range(max=TimePeriod(microseconds=436906))),
+    vol.Optional(CONF_MEASUREMENT_DURATION):
+        vol.All(cv.positive_time_period, vol.Range(max=TimePeriod(microseconds=8192))),
+    vol.Optional(CONF_LOW_VOLTAGE_REFERENCE): validate_voltage(LOW_VOLTAGE_REFERENCE),
+    vol.Optional(CONF_HIGH_VOLTAGE_REFERENCE): validate_voltage(HIGH_VOLTAGE_REFERENCE),
+    vol.Optional(CONF_VOLTAGE_ATTENUATION): validate_voltage(VOLTAGE_ATTENUATION),
+})
+
+ESP32TouchComponent = binary_sensor.binary_sensor_ns.ESP32TouchComponent
+
+
+def to_code(config):
+    rhs = App.make_esp32_touch_component()
+    touch = Pvariable(ESP32TouchComponent, config[CONF_ID], rhs)
+    if CONF_SETUP_MODE in config:
+        add(touch.set_setup_mode(config[CONF_SETUP_MODE]))
+    if CONF_IIR_FILTER in config:
+        add(touch.set_iir_filter(config[CONF_IIR_FILTER]))
+    if CONF_SLEEP_DURATION in config:
+        sleep_duration = int(config[CONF_SLEEP_DURATION].total_microseconds * 6.6667)
+        add(touch.set_sleep_duration(sleep_duration))
+    if CONF_MEASUREMENT_DURATION in config:
+        measurement_duration = int(config[CONF_MEASUREMENT_DURATION].total_microseconds * 0.125)
+        add(touch.set_measurement_duration(measurement_duration))
+    if CONF_LOW_VOLTAGE_REFERENCE in config:
+        value = LOW_VOLTAGE_REFERENCE[config[CONF_LOW_VOLTAGE_REFERENCE]]
+        add(touch.set_low_voltage_reference(value))
+    if CONF_HIGH_VOLTAGE_REFERENCE in config:
+        value = HIGH_VOLTAGE_REFERENCE[config[CONF_HIGH_VOLTAGE_REFERENCE]]
+        add(touch.set_high_voltage_reference(value))
+    if CONF_VOLTAGE_ATTENUATION in config:
+        value = VOLTAGE_ATTENUATION[config[CONF_VOLTAGE_ATTENUATION]]
+        add(touch.set_voltage_attenuation(value))
+
+
+BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'

esphomeyaml/components/fan/__init__.py

@@ -1,23 +1,63 @@
 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
+from esphomeyaml.const import CONF_ID, CONF_MQTT_ID, CONF_OSCILLATION_COMMAND_TOPIC, \
+    CONF_OSCILLATION_STATE_TOPIC, CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphomeyaml.helpers import Application, Pvariable, add, esphomelib_ns, setup_mqtt_component
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+FAN_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID('fan'): cv.register_variable_id,
+    cv.GenerateID('mqtt_fan', CONF_MQTT_ID): cv.register_variable_id,
     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)
+})
+
+fan_ns = esphomelib_ns.namespace('fan')
+FanState = fan_ns.FanState
+MQTTFanComponent = fan_ns.MQTTFanComponent
+MakeFan = Application.MakeFan
+TurnOnAction = fan_ns.TurnOnAction
+TurnOffAction = fan_ns.TurnOffAction
+ToggleAction = fan_ns.ToggleAction
+FanSpeed = fan_ns.FanSpeed
+FAN_SPEED_OFF = fan_ns.FAN_SPEED_OFF
+FAN_SPEED_LOW = fan_ns.FAN_SPEED_LOW
+FAN_SPEED_MEDIUM = fan_ns.FAN_SPEED_MEDIUM
+FAN_SPEED_HIGH = fan_ns.FAN_SPEED_HIGH
 
 
-def setup_mqtt_fan(obj, config):
+FAN_SPEEDS = {
+    'OFF': FAN_SPEED_OFF,
+    'LOW': FAN_SPEED_LOW,
+    'MEDIUM': FAN_SPEED_MEDIUM,
+    'HIGH': FAN_SPEED_HIGH,
+}
+
+
+def validate_fan_speed(value):
+    return vol.All(vol.Upper, cv.one_of(*FAN_SPEEDS))(value)
+
+
+def setup_fan_core_(fan_var, mqtt_var, config):
     if CONF_OSCILLATION_STATE_TOPIC in config:
-        add(obj.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
+        add(mqtt_var.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]))
+        add(mqtt_var.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]))
+        add(mqtt_var.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)
+        add(mqtt_var.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_fan(fan_obj, mqtt_obj, config):
+    fan_var = Pvariable(FanState, config[CONF_ID], fan_obj, has_side_effects=False)
+    mqtt_var = Pvariable(MQTTFanComponent, config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    setup_fan_core_(fan_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_FAN'

esphomeyaml/components/fan/binary.py

@@ -2,22 +2,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.const import CONF_MAKE_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,
+    cv.GenerateID('binary_fan', CONF_MAKE_ID): cv.register_variable_id,
     vol.Required(CONF_OUTPUT): cv.variable_id,
     vol.Optional(CONF_OSCILLATION_OUTPUT): cv.variable_id,
-})
+}).extend(fan.FAN_SCHEMA.schema)
 
 
 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)
+    fan_struct = variable(fan.MakeFan, config[CONF_MAKE_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)
+
+    fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)

esphomeyaml/components/fan/speed.py

@@ -2,29 +2,29 @@ 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.const import CONF_HIGH, CONF_LOW, CONF_MAKE_ID, 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,
+    cv.GenerateID('speed_fan', CONF_MAKE_ID): 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,
+        vol.Required(CONF_LOW): cv.percentage,
+        vol.Required(CONF_MEDIUM): cv.percentage,
+        vol.Required(CONF_HIGH): cv.percentage,
     }),
-})
+}).extend(fan.FAN_SCHEMA.schema)
 
 
 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)
+    fan_struct = variable(fan.MakeFan, config[CONF_MAKE_ID], rhs)
     if CONF_SPEED in config:
         speeds = config[CONF_SPEED]
         add(fan_struct.Poutput.set_speed(output, 0.0,
@@ -37,4 +37,5 @@ def to_code(config):
     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)
+
+    fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)

esphomeyaml/components/i2c.py

@@ -2,15 +2,31 @@ 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
+from esphomeyaml.const import CONF_FREQUENCY, CONF_SCL, CONF_SDA, CONF_SCAN, CONF_ID, \
+    CONF_RECEIVE_TIMEOUT
+from esphomeyaml.helpers import App, add, Pvariable, esphomelib_ns
 
 CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID('i2c'): cv.register_variable_id,
     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),
+    vol.Optional(CONF_FREQUENCY): cv.positive_int,
+    vol.Optional(CONF_RECEIVE_TIMEOUT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_SCAN): cv.boolean,
 })
 
+I2CComponent = esphomelib_ns.I2CComponent
+
 
 def to_code(config):
-    add(App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_FREQUENCY)))
+    rhs = App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_SCAN))
+    i2c = Pvariable(I2CComponent, config[CONF_ID], rhs)
+    if CONF_FREQUENCY in config:
+        add(i2c.set_frequency(config[CONF_FREQUENCY]))
+    if CONF_RECEIVE_TIMEOUT in config:
+        add(i2c.set_receive_timeout(config[CONF_RECEIVE_TIMEOUT]))
+
+
+BUILD_FLAGS = '-DUSE_I2C'
+
+LIB_DEPS = 'Wire'

esphomeyaml/components/ir_transmitter.py

@@ -2,22 +2,25 @@ 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'
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 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)),
+    vol.Optional(CONF_CARRIER_DUTY_PERCENT): vol.All(vol.Coerce(int),
+                                                     vol.Range(min=1, max=100)),
 })])
 
+IRTransmitterComponent = switch.switch_ns.namespace('IRTransmitterComponent')
+
 
 def to_code(config):
     for conf in config:
-        pin = exp_gpio_output_pin(conf[CONF_PIN])
+        pin = gpio_output_pin_expression(conf[CONF_PIN])
         rhs = App.make_ir_transmitter(pin, conf.get(CONF_CARRIER_DUTY_PERCENT))
-        Pvariable(IR_TRANSMITTER_COMPONENT_CLASS, conf[CONF_ID], rhs)
+        Pvariable(IRTransmitterComponent, conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_IR_TRANSMITTER'

esphomeyaml/components/light/__init__.py

@@ -1,13 +1,40 @@
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH
-from esphomeyaml.helpers import add, setup_mqtt_component
+from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_ID, \
+    CONF_MQTT_ID
+from esphomeyaml.helpers import Application, Pvariable, add, esphomelib_ns, setup_mqtt_component
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
-}).extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA.schema)
+})
+
+LIGHT_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID('light'): cv.register_variable_id,
+    cv.GenerateID('mqtt_light', CONF_MQTT_ID): cv.register_variable_id,
+})
+
+light_ns = esphomelib_ns.namespace('light')
+LightState = light_ns.LightState
+MQTTJSONLightComponent = light_ns.MQTTJSONLightComponent
+ToggleAction = light_ns.ToggleAction
+TurnOffAction = light_ns.TurnOffAction
+TurnOnAction = light_ns.TurnOnAction
+MakeLight = Application.MakeLight
 
 
-def setup_mqtt_light_component(obj, config):
+def setup_light_core_(light_var, mqtt_var, config):
     if CONF_DEFAULT_TRANSITION_LENGTH in config:
-        add(obj.set_default_transition_length(config[CONF_DEFAULT_TRANSITION_LENGTH]))
-    setup_mqtt_component(obj, config)
+        add(light_var.set_default_transition_length(config[CONF_DEFAULT_TRANSITION_LENGTH]))
+    if CONF_GAMMA_CORRECT in config:
+        add(light_var.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
+
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_light(light_obj, mqtt_obj, config):
+    light_var = Pvariable(LightState, config[CONF_ID], light_obj, has_side_effects=False)
+    mqtt_var = Pvariable(MQTTJSONLightComponent, config[CONF_MQTT_ID], mqtt_obj,
+                         has_side_effects=False)
+    setup_light_core_(light_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_LIGHT'

esphomeyaml/components/light/binary.py

@@ -1,19 +1,18 @@
-
 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.const import CONF_MAKE_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,
+    cv.GenerateID('binary_light', CONF_MAKE_ID): cv.register_variable_id,
     vol.Required(CONF_OUTPUT): cv.variable_id,
-})
+}).extend(light.LIGHT_SCHEMA.schema)
 
 
 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)
+    light_struct = variable(light.MakeLight, config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)

esphomeyaml/components/light/fastled_clockless.py

@@ -0,0 +1,95 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_CHIPSET, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
+    CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, \
+    CONF_RGB_ORDER
+from esphomeyaml.helpers import App, Application, RawExpression, TemplateArguments, add, \
+    get_variable, variable
+
+TYPES = [
+    'NEOPIXEL',
+    'TM1829',
+    'TM1809',
+    'TM1804',
+    'TM1803',
+    'UCS1903',
+    'UCS1903B',
+    'UCS1904',
+    'UCS2903',
+    'WS2812',
+    'WS2852',
+    'WS2812B',
+    'SK6812',
+    'SK6822',
+    'APA106',
+    'PL9823',
+    'WS2811',
+    'WS2813',
+    'APA104',
+    'WS2811_400',
+    'GW6205',
+    'GW6205_400',
+    'LPD1886',
+    'LPD1886_8BIT',
+]
+
+RGB_ORDERS = [
+    'RGB',
+    'RBG',
+    'GRB',
+    'GBR',
+    'BRG',
+    'BGR',
+]
+
+
+def validate(value):
+    if value[CONF_CHIPSET] == 'NEOPIXEL' and CONF_RGB_ORDER in value:
+        raise vol.Invalid("NEOPIXEL doesn't support RGB order")
+    return value
+
+
+PLATFORM_SCHEMA = vol.All(light.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('fast_led_clockless_light', CONF_MAKE_ID): cv.register_variable_id,
+
+    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*TYPES)),
+    vol.Required(CONF_PIN): pins.output_pin,
+
+    vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
+    vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.variable_id,
+}).extend(light.LIGHT_SCHEMA.schema), validate)
+
+MakeFastLEDLight = Application.MakeFastLEDLight
+
+
+def to_code(config):
+    rhs = App.make_fast_led_light(config[CONF_NAME])
+    make = variable(MakeFastLEDLight, config[CONF_MAKE_ID], rhs)
+    fast_led = make.Pfast_led
+
+    rgb_order = None
+    if CONF_RGB_ORDER in config:
+        rgb_order = RawExpression(config[CONF_RGB_ORDER])
+    template_args = TemplateArguments(RawExpression(config[CONF_CHIPSET]),
+                                      config[CONF_PIN], rgb_order)
+    add(fast_led.add_leds(template_args, config[CONF_NUM_LEDS]))
+
+    if CONF_MAX_REFRESH_RATE in config:
+        add(fast_led.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
+
+    if CONF_POWER_SUPPLY in config:
+        power_supply = get_variable(config[CONF_POWER_SUPPLY])
+        add(fast_led.set_power_supply(power_supply))
+
+    light.setup_light(make.Pstate, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'

esphomeyaml/components/light/fastled_spi.py

@@ -0,0 +1,75 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_CHIPSET, CONF_CLOCK_PIN, CONF_DATA_PIN, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, \
+    CONF_NAME, CONF_NUM_LEDS, CONF_POWER_SUPPLY, CONF_RGB_ORDER
+from esphomeyaml.helpers import App, Application, RawExpression, TemplateArguments, add, \
+    get_variable, variable
+
+CHIPSETS = [
+    'LPD8806',
+    'WS2801',
+    'WS2803',
+    'SM16716',
+    'P9813',
+    'APA102',
+    'SK9822',
+    'DOTSTAR',
+]
+
+RGB_ORDERS = [
+    'RGB',
+    'RBG',
+    'GRB',
+    'GBR',
+    'BRG',
+    'BGR',
+]
+
+PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('fast_led_spi_light', CONF_MAKE_ID): cv.register_variable_id,
+
+    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*CHIPSETS)),
+    vol.Required(CONF_DATA_PIN): pins.output_pin,
+    vol.Required(CONF_CLOCK_PIN): pins.output_pin,
+
+    vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
+    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
+    vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.variable_id,
+}).extend(light.LIGHT_SCHEMA.schema)
+
+MakeFastLEDLight = Application.MakeFastLEDLight
+
+
+def to_code(config):
+    rhs = App.make_fast_led_light(config[CONF_NAME])
+    make = variable(MakeFastLEDLight, config[CONF_MAKE_ID], rhs)
+    fast_led = make.Pfast_led
+
+    rgb_order = None
+    if CONF_RGB_ORDER in config:
+        rgb_order = RawExpression(config[CONF_RGB_ORDER])
+    template_args = TemplateArguments(RawExpression(config[CONF_CHIPSET]),
+                                      config[CONF_DATA_PIN],
+                                      config[CONF_CLOCK_PIN],
+                                      rgb_order)
+    add(fast_led.add_leds(template_args, config[CONF_NUM_LEDS]))
+
+    if CONF_MAX_REFRESH_RATE in config:
+        add(fast_led.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
+
+    if CONF_POWER_SUPPLY in config:
+        power_supply = get_variable(config[CONF_POWER_SUPPLY])
+        add(fast_led.set_power_supply(power_supply))
+
+        light.setup_light(make.Pstate, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'

esphomeyaml/components/light/monochromatic.py

@@ -2,22 +2,20 @@ 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, \
+from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
     CONF_NAME, CONF_OUTPUT
-from esphomeyaml.helpers import App, add, get_variable, variable
+from esphomeyaml.helpers import App, get_variable, variable
 
 PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('monochromatic_light'): cv.register_variable_id,
+    cv.GenerateID('monochromatic_light', CONF_MAKE_ID): 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,
-})
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+}).extend(light.LIGHT_SCHEMA.schema)
 
 
 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)
+    light_struct = variable(light.MakeLight, config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)

esphomeyaml/components/light/rgb.py

@@ -3,17 +3,17 @@ 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
+    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED
+from esphomeyaml.helpers import App, get_variable, variable
 
 PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('rgb_light'): cv.register_variable_id,
+    cv.GenerateID('rgb_light', CONF_MAKE_ID): 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,
-})
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+}).extend(light.LIGHT_SCHEMA.schema)
 
 
 def to_code(config):
@@ -21,7 +21,5 @@ def to_code(config):
     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)
+    light_struct = variable(light.MakeLight, config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)

esphomeyaml/components/light/rgbw.py

@@ -3,18 +3,18 @@ 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
+    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_WHITE
+from esphomeyaml.helpers import App, get_variable, variable
 
 PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('rgbw_light'): cv.register_variable_id,
+    cv.GenerateID('rgbw_light', CONF_MAKE_ID): 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,
-})
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+}).extend(light.LIGHT_SCHEMA.schema)
 
 
 def to_code(config):
@@ -23,7 +23,5 @@ def to_code(config):
     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)
+    light_struct = variable(light.MakeLight, config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)

esphomeyaml/components/logger.py

@@ -2,61 +2,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
+    CONF_TX_BUFFER_SIZE
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, RawExpression, add, exp_empty_optional
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, global_ns
 
-LOG_LEVELS = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE']
+LOG_LEVELS = {
+    'NONE': global_ns.ESPHOMELIB_LOG_LEVEL_NONE,
+    'ERROR': global_ns.ESPHOMELIB_LOG_LEVEL_ERROR,
+    'WARN': global_ns.ESPHOMELIB_LOG_LEVEL_WARN,
+    'INFO': global_ns.ESPHOMELIB_LOG_LEVEL_INFO,
+    'DEBUG': global_ns.ESPHOMELIB_LOG_LEVEL_DEBUG,
+    'VERBOSE': global_ns.ESPHOMELIB_LOG_LEVEL_VERBOSE,
+    'VERY_VERBOSE': global_ns.ESPHOMELIB_LOG_LEVEL_VERY_VERBOSE,
+}
 
+LOG_LEVEL_SEVERITY = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE', 'VERY_VERBOSE']
 
 # pylint: disable=invalid-name
-is_log_level = vol.All(vol.Upper, vol.Any(*LOG_LEVELS))
+is_log_level = vol.All(vol.Upper, cv.one_of(*LOG_LEVELS))
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+
+def validate_local_no_higher_than_global(value):
+    global_level = value.get(CONF_LEVEL, 'DEBUG')
+    for tag, level in value.get(CONF_LOGS, {}).iteritems():
+        if LOG_LEVEL_SEVERITY.index(level) > LOG_LEVEL_SEVERITY.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))
+    return value
+
+
+CONFIG_SCHEMA = vol.All(vol.Schema({
     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,
     })
-})
+}), validate_local_no_higher_than_global)
 
-
-def esphomelib_log_level(level):
-    return u'ESPHOMELIB_LOG_LEVEL_{}'.format(level)
-
-
-def exp_log_level(level):
-    return RawExpression(esphomelib_log_level(level))
+LogComponent = esphomelib_ns.LogComponent
 
 
 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)
+    rhs = App.init_log(config.get(CONF_BAUD_RATE))
+    log = Pvariable(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])))
+        add(log.set_global_log_level(LOG_LEVELS[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)))
+        add(log.set_log_level(tag, LOG_LEVELS[level]))
 
 
-def get_build_flags(config):
+def required_build_flags(config):
     if CONF_LEVEL in config:
-        return u'-DESPHOMELIB_LOG_LEVEL={}'.format(esphomelib_log_level(config[CONF_LEVEL]))
-    return u''
+        return u'-DESPHOMELIB_LOG_LEVEL={}'.format(str(LOG_LEVELS[config[CONF_LEVEL]]))
+    return None

esphomeyaml/components/mqtt.py

@@ -1,25 +1,44 @@
+import re
+
 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
+from esphomeyaml import automation
+from esphomeyaml.const import CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_CLIENT_ID, CONF_DISCOVERY, \
+    CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, CONF_ID, CONF_KEEPALIVE, CONF_LOG_TOPIC, \
+    CONF_MQTT, CONF_ON_MESSAGE, CONF_PASSWORD, CONF_PAYLOAD, CONF_PORT, CONF_QOS, CONF_RETAIN, \
+    CONF_SSL_FINGERPRINTS, CONF_TOPIC, CONF_TOPIC_PREFIX, CONF_TRIGGER_ID, CONF_USERNAME, \
+    CONF_WILL_MESSAGE
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, StructInitializer, \
+    TemplateArguments, add, esphomelib_ns, optional, std_string, RawExpression
 
-MQTT_WILL_BIRTH_SCHEMA = vol.Any(None, vol.Schema({
+
+def validate_message_just_topic(value):
+    value = cv.publish_topic(value)
+    return {CONF_TOPIC: value}
+
+
+MQTT_MESSAGE_BASE = 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_QOS, default=0): cv.mqtt_qos,
     vol.Optional(CONF_RETAIN, default=True): cv.boolean,
+})
+
+MQTT_MESSAGE_TEMPLATE_SCHEMA = vol.Any(None, MQTT_MESSAGE_BASE, validate_message_just_topic)
+
+MQTT_MESSAGE_SCHEMA = vol.Any(None, MQTT_MESSAGE_BASE.extend({
+    vol.Required(CONF_PAYLOAD): cv.mqtt_payload,
 }))
 
+mqtt_ns = esphomelib_ns.namespace('mqtt')
+MQTTMessage = mqtt_ns.MQTTMessage
+MQTTClientComponent = mqtt_ns.MQTTClientComponent
+MQTTPublishAction = mqtt_ns.MQTTPublishAction
+MQTTMessageTrigger = mqtt_ns.MQTTMessageTrigger
+
 
 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")
     if not value:
@@ -27,7 +46,14 @@ def validate_broker(value):
     return value
 
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+def validate_fingerprint(value):
+    value = cv.string(value)
+    if re.match(r'^[0-9a-f]{40}$', value) is None:
+        raise vol.Invalid(u"fingerprint must be valid SHA1 hash")
+    return value
+
+
+CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(CONF_MQTT): cv.register_variable_id,
     vol.Required(CONF_BROKER): validate_broker,
     vol.Optional(CONF_PORT, default=1883): cv.port,
@@ -37,19 +63,27 @@ CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
     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_BIRTH_MESSAGE): MQTT_MESSAGE_SCHEMA,
+    vol.Optional(CONF_WILL_MESSAGE): MQTT_MESSAGE_SCHEMA,
     vol.Optional(CONF_TOPIC_PREFIX): cv.publish_topic,
+    vol.Optional(CONF_LOG_TOPIC): MQTT_MESSAGE_TEMPLATE_SCHEMA,
+    vol.Optional(CONF_SSL_FINGERPRINTS): vol.All(cv.only_on_esp8266,
+                                                 cv.ensure_list, [validate_fingerprint]),
+    vol.Optional(CONF_KEEPALIVE): cv.positive_time_period_seconds,
+    vol.Optional(CONF_ON_MESSAGE): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA.extend({
+        vol.Required(CONF_TOPIC): cv.publish_topic,
+        vol.Optional(CONF_QOS, 0): cv.mqtt_qos,
+    })])
 })
 
 
 def exp_mqtt_message(config):
     if config is None:
-        return exp_empty_optional('mqtt::MQTTMessage')
+        return optional(TemplateArguments(MQTTMessage))
     exp = StructInitializer(
-        'mqtt::MQTTMessage',
+        MQTTMessage,
         ('topic', config[CONF_TOPIC]),
-        ('payload', config[CONF_PAYLOAD]),
+        ('payload', config.get(CONF_PAYLOAD, "")),
         ('qos', config[CONF_QOS]),
         ('retain', config[CONF_RETAIN])
     )
@@ -59,18 +93,49 @@ def exp_mqtt_message(config):
 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)
+    mqtt = Pvariable(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_BIRTH_MESSAGE in config:
+        birth_message = config[CONF_BIRTH_MESSAGE]
+        if birth_message is None:
+            add(mqtt.disable_birth_message())
+        else:
+            add(mqtt.set_birth_message(exp_mqtt_message(birth_message)))
+    if CONF_WILL_MESSAGE in config:
+        will_message = config[CONF_WILL_MESSAGE]
+        if will_message is None:
+            add(mqtt.disable_last_will())
+        else:
+            add(mqtt.set_last_will(exp_mqtt_message(will_message)))
     if CONF_CLIENT_ID in config:
         add(mqtt.set_client_id(config[CONF_CLIENT_ID]))
+    if CONF_LOG_TOPIC in config:
+        log_topic = config[CONF_LOG_TOPIC]
+        if log_topic is None:
+            add(mqtt.disable_log_message())
+        else:
+            add(mqtt.set_log_topic(exp_mqtt_message(log_topic)))
+    if CONF_SSL_FINGERPRINTS in config:
+        for fingerprint in config[CONF_SSL_FINGERPRINTS]:
+            arr = [RawExpression("0x{}".format(fingerprint[i:i + 2])) for i in range(0, 40, 2)]
+            add(mqtt.add_ssl_fingerprint(ArrayInitializer(*arr, multiline=False)))
+    if CONF_KEEPALIVE in config:
+        add(mqtt.set_keep_alive(config[CONF_KEEPALIVE]))
+
+    for conf in config.get(CONF_ON_MESSAGE, []):
+        rhs = mqtt.make_message_trigger(conf[CONF_TOPIC], conf[CONF_QOS])
+        trigger = Pvariable(MQTTMessageTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, std_string, conf)
+
+
+def required_build_flags(config):
+    if CONF_SSL_FINGERPRINTS in config:
+        return '-DASYNC_TCP_SSL_ENABLED=1'
+    return None

esphomeyaml/components/ota.py

@@ -4,14 +4,15 @@ import logging
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
+from esphomeyaml import core
 from esphomeyaml.const import CONF_ID, CONF_OTA, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE, \
-    ESP_PLATFORM_ESP8266, ESP_PLATFORM_ESP32
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, add
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns
 
 _LOGGER = logging.getLogger(__name__)
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
+CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(CONF_OTA): cv.register_variable_id,
     vol.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
     # TODO Num attempts + wait time
@@ -19,10 +20,12 @@ CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
     vol.Optional(CONF_PASSWORD): cv.string,
 })
 
+OTAComponent = esphomelib_ns.OTAComponent
+
 
 def to_code(config):
     rhs = App.init_ota()
-    ota = Pvariable('OTAComponent', config[CONF_ID], rhs)
+    ota = Pvariable(OTAComponent, config[CONF_ID], rhs)
     if CONF_PASSWORD in config:
         hash_ = hashlib.md5(config[CONF_PASSWORD].encode()).hexdigest()
         add(ota.set_auth_password_hash(hash_))
@@ -33,12 +36,21 @@ def to_code(config):
 def get_port(config):
     if CONF_PORT in config[CONF_OTA]:
         return config[CONF_OTA][CONF_PORT]
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         return 3232
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.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, '')
+
+
+BUILD_FLAGS = '-DUSE_OTA'
+
+
+def lib_deps(config):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return ['ArduinoOTA', 'Update', 'ESPmDNS']
+    return ['Hash', 'ESP8266mDNS', 'ArduinoOTA']

esphomeyaml/components/output/__init__.py

@@ -1,19 +1,24 @@
-
 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
+from esphomeyaml.const import CONF_INVERTED, CONF_MAX_POWER, CONF_POWER_SUPPLY
+from esphomeyaml.helpers import add, esphomelib_ns, get_variable
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+BINARY_OUTPUT_SCHEMA = cv.REQUIRED_ID_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,
 })
 
+FLOAT_OUTPUT_SCHEMA = BINARY_OUTPUT_SCHEMA.extend({
+    vol.Optional(CONF_MAX_POWER): cv.percentage,
+})
+
+output_ns = esphomelib_ns.namespace('output')
+
 
 def setup_output_platform(obj, config, skip_power_supply=False):
     if CONF_INVERTED in config:
@@ -23,3 +28,6 @@ def setup_output_platform(obj, config, skip_power_supply=False):
         add(obj.set_power_supply(power_supply))
     if CONF_MAX_POWER in config:
         add(obj.set_max_power(config[CONF_MAX_POWER]))
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'

esphomeyaml/components/output/esp8266_pwm.py

@@ -2,23 +2,31 @@ 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.const import CONF_ID, CONF_PIN, ESP_PLATFORM_ESP8266, CONF_NUMBER
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin, get_gpio_pin_number
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
 
-PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-})
+
+def valid_pwm_pin(value):
+    if value[CONF_NUMBER] >= 16:
+        raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
+    return value
+
+
+PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PIN): vol.All(pins.GPIO_INTERNAL_OUTPUT_PIN_SCHEMA, valid_pwm_pin),
+}).extend(output.FLOAT_OUTPUT_SCHEMA.schema)
+
+ESP8266PWMOutput = output.output_ns.ESP8266PWMOutput
 
 
 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])
+    pin = gpio_output_pin_expression(config[CONF_PIN])
     rhs = App.make_esp8266_pwm_output(pin)
-    gpio = Pvariable('output::ESP8266PWMOutput', config[CONF_ID], rhs)
+    gpio = Pvariable(ESP8266PWMOutput, config[CONF_ID], rhs)
     output.setup_output_platform(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP8266_PWM_OUTPUT'

esphomeyaml/components/output/gpio.py

@@ -3,15 +3,20 @@ 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
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-})
+}).extend(output.BINARY_OUTPUT_SCHEMA.schema)
+
+GPIOBinaryOutputComponent = output.output_ns.GPIOBinaryOutputComponent
 
 
 def to_code(config):
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    pin = gpio_output_pin_expression(config[CONF_PIN])
     rhs = App.make_gpio_output(pin)
-    gpio = Pvariable('output::GPIOBinaryOutputComponent', config[CONF_ID], rhs)
+    gpio = Pvariable(GPIOBinaryOutputComponent, config[CONF_ID], rhs)
     output.setup_output_platform(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_OUTPUT'

esphomeyaml/components/output/ledc.py

@@ -19,12 +19,15 @@ def validate_frequency_bit_depth(obj):
     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)),
+PLATFORM_SCHEMA = vol.All(output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PIN): pins.output_pin,
     vol.Optional(CONF_FREQUENCY): cv.frequency,
     vol.Optional(CONF_BIT_DEPTH): vol.All(vol.Coerce(int), vol.Range(min=1, max=15)),
     vol.Optional(CONF_CHANNEL): vol.All(vol.Coerce(int), vol.Range(min=0, max=15))
-}), validate_frequency_bit_depth)
+}).extend(output.FLOAT_OUTPUT_SCHEMA.schema), validate_frequency_bit_depth)
+
+
+LEDCOutputComponent = output.output_ns.LEDCOutputComponent
 
 
 def to_code(config):
@@ -32,7 +35,10 @@ def to_code(config):
     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)
+    ledc = Pvariable(LEDCOutputComponent, config[CONF_ID], rhs)
     if CONF_CHANNEL in config:
         add(ledc.set_channel(config[CONF_CHANNEL]))
     output.setup_output_platform(ledc, config)
+
+
+BUILD_FLAGS = '-DUSE_LEDC_OUTPUT'

esphomeyaml/components/output/pca9685.py

@@ -2,24 +2,29 @@ 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.components.pca9685 import PCA9685OutputComponent
 from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY
 from esphomeyaml.helpers import Pvariable, get_variable
 
 DEPENDENCIES = ['pca9685']
 
-PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = output.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,
-})
+}).extend(output.FLOAT_OUTPUT_SCHEMA.schema)
+
+Channel = PCA9685OutputComponent.Channel
 
 
 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)
+    pca9685 = get_variable(config.get(CONF_PCA9685_ID), PCA9685OutputComponent)
     rhs = pca9685.create_channel(config[CONF_CHANNEL], power_supply)
-    out = Pvariable('output::PCA9685OutputComponent::Channel', config[CONF_ID], rhs)
+    out = Pvariable(Channel, config[CONF_ID], rhs)
     output.setup_output_platform(out, config, skip_power_supply=True)
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphomeyaml/components/pca9685.py

@@ -1,21 +1,24 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import output
 from esphomeyaml.const import CONF_ADDRESS, CONF_FREQUENCY, CONF_ID, CONF_PHASE_BALANCER
-from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, RawExpression, add
+from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, add
 
 DEPENDENCIES = ['i2c']
 
-PHASE_BALANCERS = ['None', 'Linear', 'Weaved']
+PCA9685OutputComponent = output.output_ns.namespace('PCA9685OutputComponent')
 
-PCA9685_COMPONENT_TYPE = 'output::PCA9685OutputComponent'
+PHASE_BALANCER_MESSAGE = ("The phase_balancer option has been removed in version 1.5.0. "
+                          "esphomelib will now automatically choose a suitable phase balancer.")
 
 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.Range(min=23.84, max=1525.88)),
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
+
+    vol.Optional(CONF_PHASE_BALANCER): cv.invalid(PHASE_BALANCER_MESSAGE),
 })
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCA9685_SCHEMA])
@@ -24,10 +27,9 @@ 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)
+        pca9685 = Pvariable(PCA9685OutputComponent, 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))
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphomeyaml/components/pcf8574.py

@@ -0,0 +1,27 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_PCF8575
+from esphomeyaml.helpers import App, Pvariable, esphomelib_ns
+
+DEPENDENCIES = ['i2c']
+
+PCF8574_SCHEMA = vol.Schema({
+    vol.Required(CONF_ID): cv.register_variable_id,
+    vol.Optional(CONF_ADDRESS, default=0x21): cv.i2c_address,
+    vol.Optional(CONF_PCF8575, default=False): cv.boolean,
+})
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCF8574_SCHEMA])
+
+io_ns = esphomelib_ns.namespace('io')
+PCF8574Component = io_ns.PCF8574Component
+
+
+def to_code(config):
+    for conf in config:
+        rhs = App.make_pcf8574_component(conf[CONF_ADDRESS], conf[CONF_PCF8575])
+        Pvariable(PCF8574Component, conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_PCF8574'

esphomeyaml/components/power_supply.py

@@ -3,23 +3,27 @@ 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
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, gpio_output_pin_expression
 
 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,
+    vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period_milliseconds,
 })
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [POWER_SUPPLY_SCHEMA])
 
+PowerSupplyComponent = esphomelib_ns.PowerSupplyComponent
+
 
 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)
+        rhs = App.make_power_supply(gpio_output_pin_expression(conf[CONF_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]))
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'

esphomeyaml/components/sensor/__init__.py

@@ -1,101 +1,176 @@
 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
+from esphomeyaml import automation
+from esphomeyaml.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
+    CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, \
+    CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_LAMBDA, \
+    CONF_MQTT_ID, CONF_MULTIPLY, CONF_NAME, CONF_OFFSET, CONF_ON_RAW_VALUE, CONF_ON_VALUE,\
+    CONF_ON_VALUE_RANGE, CONF_OR, CONF_SEND_EVERY, CONF_SLIDING_WINDOW_MOVING_AVERAGE, \
+    CONF_THROTTLE, CONF_TRIGGER_ID, CONF_UNIQUE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, add, esphomelib_ns, float_, \
+    process_lambda, setup_mqtt_component, templatable
 
 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({
+def validate_recursive_filter(value):
+    return FILTERS_SCHEMA(value)
+
+
+FILTER_KEYS = [CONF_OFFSET, CONF_MULTIPLY, CONF_FILTER_OUT, CONF_FILTER_NAN,
+               CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_LAMBDA,
+               CONF_THROTTLE, CONF_DELTA, CONF_UNIQUE, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR]
+
+FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
+    vol.Optional(CONF_OFFSET): vol.Coerce(float),
+    vol.Optional(CONF_MULTIPLY): vol.Coerce(float),
+    vol.Optional(CONF_FILTER_OUT): vol.Coerce(float),
+    vol.Optional(CONF_FILTER_NAN): None,
+    vol.Optional(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.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
+        vol.Required(CONF_ALPHA): cv.positive_float,
+        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+    }),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_THROTTLE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DELTA): vol.Coerce(float),
+    vol.Optional(CONF_UNIQUE): None,
+    vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DEBOUNCE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_OR): validate_recursive_filter,
+}, cv.has_at_exactly_one_key(*FILTER_KEYS))])
+
+SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID('mqtt_sensor', CONF_MQTT_ID): cv.register_variable_id,
+    cv.GenerateID('sensor'): cv.register_variable_id,
     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,
+    vol.Optional(CONF_EXPIRE_AFTER): vol.Any(None, cv.positive_time_period_milliseconds),
+    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
+    vol.Optional(CONF_ON_VALUE): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA]),
+    vol.Optional(CONF_ON_RAW_VALUE): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA]),
+    vol.Optional(CONF_ON_VALUE_RANGE): vol.All(cv.ensure_list, [vol.All(
+        automation.AUTOMATION_SCHEMA.extend({
+            vol.Optional(CONF_ABOVE): vol.Coerce(float),
+            vol.Optional(CONF_BELOW): vol.Coerce(float),
+        }), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))]),
 })
 
 # pylint: disable=invalid-name
-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')
+sensor_ns = esphomelib_ns.namespace('sensor')
+Sensor = sensor_ns.Sensor
+MQTTSensorComponent = sensor_ns.MQTTSensorComponent
+OffsetFilter = sensor_ns.OffsetFilter
+MultiplyFilter = sensor_ns.MultiplyFilter
+FilterOutValueFilter = sensor_ns.FilterOutValueFilter
+FilterOutNANFilter = sensor_ns.FilterOutNANFilter
+SlidingWindowMovingAverageFilter = sensor_ns.SlidingWindowMovingAverageFilter
+ExponentialMovingAverageFilter = sensor_ns.ExponentialMovingAverageFilter
+LambdaFilter = sensor_ns.LambdaFilter
+ThrottleFilter = sensor_ns.ThrottleFilter
+DeltaFilter = sensor_ns.DeltaFilter
+OrFilter = sensor_ns.OrFilter
+HeartbeatFilter = sensor_ns.HeartbeatFilter
+DebounceFilter = sensor_ns.DebounceFilter
+UniqueFilter = sensor_ns.UniqueFilter
+
+SensorValueTrigger = sensor_ns.SensorValueTrigger
+RawSensorValueTrigger = sensor_ns.RawSensorValueTrigger
+ValueRangeTrigger = sensor_ns.ValueRangeTrigger
 
 
 def setup_filter(config):
     if CONF_OFFSET in config:
-        return OffsetFilter(config[CONF_OFFSET])
+        return OffsetFilter.new(config[CONF_OFFSET])
     if CONF_MULTIPLY in config:
-        return MultiplyFilter(config[CONF_MULTIPLY])
+        return MultiplyFilter.new(config[CONF_MULTIPLY])
     if CONF_FILTER_OUT in config:
-        return FilterOutValueFilter(config[CONF_FILTER_OUT])
+        return FilterOutValueFilter.new(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])
+        return SlidingWindowMovingAverageFilter.new(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])
+        return ExponentialMovingAverageFilter.new(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))
+        return LambdaFilter.new(process_lambda(config[CONF_LAMBDA], [(float_, 'x')]))
+    if CONF_THROTTLE in config:
+        return ThrottleFilter.new(config[CONF_THROTTLE])
+    if CONF_DELTA in config:
+        return DeltaFilter.new(config[CONF_DELTA])
+    if CONF_OR in config:
+        return OrFilter.new(setup_filters(config[CONF_OR]))
+    if CONF_HEARTBEAT in config:
+        return App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
+    if CONF_DEBOUNCE in config:
+        return App.register_component(DebounceFilter.new(config[CONF_DEBOUNCE]))
+    if CONF_UNIQUE in config:
+        return UniqueFilter.new()
+    raise ValueError(u"Filter unsupported: {}".format(config))
 
 
-def setup_mqtt_sensor_component(obj, config):
+def setup_filters(config):
+    return ArrayInitializer(*[setup_filter(x) for x in config])
+
+
+def setup_sensor_core_(sensor_var, mqtt_var, config):
     if CONF_UNIT_OF_MEASUREMENT in config:
-        add(obj.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+        add(sensor_var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
     if CONF_ICON in config:
-        add(obj.set_icon(config[CONF_ICON]))
+        add(sensor_var.set_icon(config[CONF_ICON]))
     if CONF_ACCURACY_DECIMALS in config:
-        add(obj.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+        add(sensor_var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_FILTERS in config:
+        add(sensor_var.set_filters(setup_filters(config[CONF_FILTERS])))
+
+    for conf in config.get(CONF_ON_VALUE, []):
+        rhs = sensor_var.make_value_trigger()
+        trigger = Pvariable(SensorValueTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, float_, conf)
+    for conf in config.get(CONF_ON_RAW_VALUE, []):
+        rhs = sensor_var.make_raw_value_trigger()
+        trigger = Pvariable(RawSensorValueTrigger, conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, float_, conf)
+    for conf in config.get(CONF_ON_VALUE_RANGE, []):
+        rhs = sensor_var.make_value_range_trigger()
+        trigger = Pvariable(ValueRangeTrigger, conf[CONF_TRIGGER_ID], rhs)
+        if CONF_ABOVE in conf:
+            trigger.set_min(templatable(conf[CONF_ABOVE], float_, float_))
+        if CONF_BELOW in conf:
+            trigger.set_max(templatable(conf[CONF_BELOW], float_, float_))
+        automation.build_automation(trigger, float_, conf)
+
     if CONF_EXPIRE_AFTER in config:
         if config[CONF_EXPIRE_AFTER] is None:
-            add(obj.disable_expire_after())
+            add(mqtt_var.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)
+            add(mqtt_var.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    setup_mqtt_component(mqtt_var, 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)
+def setup_sensor(sensor_obj, mqtt_obj, config):
+    sensor_var = Pvariable(Sensor, config[CONF_ID], sensor_obj, has_side_effects=False)
+    mqtt_var = Pvariable(MQTTSensorComponent, config[CONF_MQTT_ID], mqtt_obj,
+                         has_side_effects=False)
+    setup_sensor_core_(sensor_var, mqtt_var, config)
+
+
+def register_sensor(var, config):
+    sensor_var = Pvariable(Sensor, config[CONF_ID], var, has_side_effects=True)
+    rhs = App.register_sensor(sensor_var)
+    mqtt_var = Pvariable(MQTTSensorComponent, config[CONF_MQTT_ID], rhs,
+                         has_side_effects=True)
+    setup_sensor_core_(sensor_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SENSOR'

esphomeyaml/components/sensor/adc.py

@@ -3,33 +3,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, \
+from esphomeyaml.const import CONF_ATTENUATION, CONF_MAKE_ID, CONF_NAME, CONF_PIN, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, RawExpression, add, variable
+from esphomeyaml.helpers import App, Application, add, global_ns, variable
 
 ATTENUATION_MODES = {
-    '0db': 'ADC_0db',
-    '2.5db': 'ADC_2_5db',
-    '6db': 'ADC_6db',
-    '11db': 'ADC_11db',
+    '0db': global_ns.ADC_0db,
+    '2.5db': global_ns.ADC_2_5db,
+    '6db': global_ns.ADC_6db,
+    '11db': global_ns.ADC_11db,
 }
 
-ATTENUATION_MODE_SCHEMA = vol.Any(*list(ATTENUATION_MODES.keys()))
-
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('adc'): cv.register_variable_id,
+    cv.GenerateID('adc', CONF_MAKE_ID): 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)
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeADCSensor = Application.MakeADCSensor
 
 
 def to_code(config):
-    rhs = App.make_adc_sensor(config[CONF_PIN], config[CONF_NAME],
+    rhs = App.make_adc_sensor(config[CONF_NAME], config[CONF_PIN],
                               config.get(CONF_UPDATE_INTERVAL))
-    make = variable('Application::MakeADCSensor', config[CONF_ID], rhs)
+    make = variable(MakeADCSensor, config[CONF_MAKE_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)
+        add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
+    sensor.setup_sensor(make.Padc, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_ADC_SENSOR'

esphomeyaml/components/sensor/ads1115.py

@@ -2,29 +2,31 @@ 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
+from esphomeyaml.components.ads1115 import ADS1115Component
+from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import get_variable
 
 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',
+    'A0_A1': sensor.sensor_ns.ADS1115_MULTIPLEXER_P0_N1,
+    'A0_A3': sensor.sensor_ns.ADS1115_MULTIPLEXER_P0_N3,
+    'A1_A3': sensor.sensor_ns.ADS1115_MULTIPLEXER_P1_N3,
+    'A2_A3': sensor.sensor_ns.ADS1115_MULTIPLEXER_P2_N3,
+    'A0_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P0_NG,
+    'A1_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P1_NG,
+    'A2_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P2_NG,
+    'A3_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_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',
+    '6.144': sensor.sensor_ns.ADS1115_GAIN_6P144,
+    '4.096': sensor.sensor_ns.ADS1115_GAIN_6P096,
+    '2.048': sensor.sensor_ns.ADS1115_GAIN_2P048,
+    '1.024': sensor.sensor_ns.ADS1115_GAIN_1P024,
+    '0.512': sensor.sensor_ns.ADS1115_GAIN_0P512,
+    '0.256': sensor.sensor_ns.ADS1115_GAIN_0P256,
 }
 
 
@@ -34,23 +36,31 @@ def validate_gain(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
+    return cv.one_of(*GAIN)(value)
+
+
+def validate_mux(value):
+    value = cv.string(value).upper()
+    value = value.replace(' ', '_')
+    return cv.one_of(*MUX)(value)
 
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_MULTIPLEXER): vol.All(vol.Upper, vol.Any(*list(MUX.keys()))),
+    cv.GenerateID('ads1115_sensor'): cv.register_variable_id,
+    vol.Required(CONF_MULTIPLEXER): validate_mux,
     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)
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
 
 
 def to_code(config):
-    hub = get_variable(config.get(CONF_ADS1115_ID), u'sensor::ADS1115Component')
+    hub = get_variable(config.get(CONF_ADS1115_ID), 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)
+    mux = MUX[config[CONF_MULTIPLEXER]]
+    gain = GAIN[config[CONF_GAIN]]
+    rhs = hub.get_sensor(config[CONF_NAME], mux, gain, config.get(CONF_UPDATE_INTERVAL))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphomeyaml/components/sensor/bh1750.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+BH1750_RESOLUTIONS = {
+    4.0: sensor.sensor_ns.BH1750_RESOLUTION_4P0_LX,
+    1.0: sensor.sensor_ns.BH1750_RESOLUTION_1P0_LX,
+    0.5: sensor.sensor_ns.BH1750_RESOLUTION_0P5_LX,
+}
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('bh1750_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_ADDRESS, default=0x23): cv.i2c_address,
+    vol.Optional(CONF_RESOLUTION): vol.All(cv.positive_float, cv.one_of(*BH1750_RESOLUTIONS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeBH1750Sensor = Application.MakeBH1750Sensor
+
+
+def to_code(config):
+    rhs = App.make_bh1750_sensor(config[CONF_NAME], config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    make_bh1750 = variable(MakeBH1750Sensor, config[CONF_MAKE_ID], rhs)
+    bh1750 = make_bh1750.Pbh1750
+    if CONF_RESOLUTION in config:
+        add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
+    sensor.setup_sensor(bh1750, make_bh1750.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_BH1750'

esphomeyaml/components/sensor/bme280.py

@@ -0,0 +1,74 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_IIR_FILTER, CONF_MAKE_ID, \
+    CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+OVERSAMPLING_OPTIONS = {
+    'NONE': sensor.sensor_ns.BME280_OVERSAMPLING_NONE,
+    '1X': sensor.sensor_ns.BME280_OVERSAMPLING_1X,
+    '2X': sensor.sensor_ns.BME280_OVERSAMPLING_2X,
+    '4X': sensor.sensor_ns.BME280_OVERSAMPLING_4X,
+    '8X': sensor.sensor_ns.BME280_OVERSAMPLING_8X,
+    '16X': sensor.sensor_ns.BME280_OVERSAMPLING_16X,
+}
+
+IIR_FILTER_OPTIONS = {
+    'OFF': sensor.sensor_ns.BME280_IIR_FILTER_OFF,
+    '2X': sensor.sensor_ns.BME280_IIR_FILTER_2X,
+    '4X': sensor.sensor_ns.BME280_IIR_FILTER_4X,
+    '8X': sensor.sensor_ns.BME280_IIR_FILTER_8X,
+    '16X': sensor.sensor_ns.BME280_IIR_FILTER_16X,
+}
+
+BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('bme280', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): BME280_OVERSAMPLING_SENSOR_SCHEMA,
+    vol.Required(CONF_PRESSURE): BME280_OVERSAMPLING_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): BME280_OVERSAMPLING_SENSOR_SCHEMA,
+    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+})
+
+MakeBME280Sensor = Application.MakeBME280Sensor
+
+
+def to_code(config):
+    rhs = App.make_bme280_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    make = variable(MakeBME280Sensor, config[CONF_MAKE_ID], rhs)
+    bme280 = make.Pbme280
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bme280.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bme280.set_pressure_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_HUMIDITY]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_HUMIDITY][CONF_OVERSAMPLING]]
+        add(bme280.set_humidity_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bme280.set_iir_filter(constant))
+
+    sensor.setup_sensor(bme280.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme280.Pget_pressure_sensor(), make.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    sensor.setup_sensor(bme280.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_BME280'

esphomeyaml/components/sensor/bme680.py

@@ -0,0 +1,83 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_GAS_RESISTANCE, CONF_HUMIDITY, CONF_IIR_FILTER, \
+    CONF_MAKE_ID, CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+OVERSAMPLING_OPTIONS = {
+    'NONE': sensor.sensor_ns.BME680_OVERSAMPLING_NONE,
+    '1X': sensor.sensor_ns.BME680_OVERSAMPLING_1X,
+    '2X': sensor.sensor_ns.BME680_OVERSAMPLING_2X,
+    '4X': sensor.sensor_ns.BME680_OVERSAMPLING_4X,
+    '8X': sensor.sensor_ns.BME680_OVERSAMPLING_8X,
+    '16X': sensor.sensor_ns.BME680_OVERSAMPLING_16X,
+}
+
+IIR_FILTER_OPTIONS = {
+    'OFF': sensor.sensor_ns.BME680_IIR_FILTER_OFF,
+    '1X': sensor.sensor_ns.BME680_IIR_FILTER_1X,
+    '3X': sensor.sensor_ns.BME680_IIR_FILTER_3X,
+    '7X': sensor.sensor_ns.BME680_IIR_FILTER_7X,
+    '15X': sensor.sensor_ns.BME680_IIR_FILTER_15X,
+    '31X': sensor.sensor_ns.BME680_IIR_FILTER_31X,
+    '63X': sensor.sensor_ns.BME680_IIR_FILTER_63X,
+    '127X': sensor.sensor_ns.BME680_IIR_FILTER_127X,
+}
+
+BME680_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('bme680', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_ADDRESS, default=0x76): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): BME680_OVERSAMPLING_SENSOR_SCHEMA,
+    vol.Required(CONF_PRESSURE): BME680_OVERSAMPLING_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): BME680_OVERSAMPLING_SENSOR_SCHEMA,
+    vol.Required(CONF_GAS_RESISTANCE): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    # TODO: Heater
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+})
+
+MakeBME680Sensor = Application.MakeBME680Sensor
+
+
+def to_code(config):
+    rhs = App.make_bme680_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config[CONF_GAS_RESISTANCE][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    make = variable(MakeBME680Sensor, config[CONF_MAKE_ID], rhs)
+    bme680 = make.Pbme680
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bme680.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bme680.set_pressure_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_HUMIDITY]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_HUMIDITY][CONF_OVERSAMPLING]]
+        add(bme680.set_humidity_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bme680.set_iir_filter(constant))
+
+    sensor.setup_sensor(bme680.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme680.Pget_pressure_sensor(), make.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    sensor.setup_sensor(bme680.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(bme680.Pget_gas_resistance_sensor(), make.Pmqtt_gas_resistance,
+                        config[CONF_GAS_RESISTANCE])
+
+
+BUILD_FLAGS = '-DUSE_BME680'

esphomeyaml/components/sensor/bmp085.py

@@ -2,28 +2,35 @@ 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
+from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, HexIntLiteral, add, variable, Application
 
 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,
+    cv.GenerateID('bmp085_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Required(CONF_PRESSURE): sensor.SENSOR_SCHEMA,
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
 })
 
+MakeBMP085Sensor = Application.MakeBMP085Sensor
+
 
 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)
+    bmp = variable(MakeBMP085Sensor, config[CONF_MAKE_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])
+
+    sensor.setup_sensor(bmp.Pbmp.Pget_temperature_sensor(), bmp.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp.Pbmp.Pget_pressure_sensor(), bmp.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+
+
+BUILD_FLAGS = '-DUSE_BMP085_SENSOR'

esphomeyaml/components/sensor/dallas.py

@@ -2,30 +2,33 @@ 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.components.dallas import DallasComponent
+from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
+    CONF_RESOLUTION, CONF_UPDATE_INTERVAL
 from esphomeyaml.helpers import HexIntLiteral, get_variable
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = vol.All(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)
+}).extend(sensor.SENSOR_SCHEMA.schema), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
 
 
 def to_code(config):
-    hub = get_variable(config.get(CONF_DALLAS_ID), DALLAS_COMPONENT_CLASS)
+    hub = get_variable(config.get(CONF_DALLAS_ID), DallasComponent)
     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))
+        rhs = hub.Pget_sensor_by_address(config[CONF_NAME], 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)
+        rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
+                                       update_interval, config.get(CONF_RESOLUTION))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphomeyaml/components/sensor/dht.py

@@ -1,31 +1,46 @@
 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, \
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
     CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, RawExpression, add, variable
+from esphomeyaml.helpers import App, Application, add, gpio_output_pin_expression, variable
+from esphomeyaml.pins import GPIO_OUTPUT_PIN_SCHEMA
 
-DHT_MODELS = ['AUTO_DETECT', 'DHT11', 'DHT22', 'AM2302', 'RHT03']
+DHT_MODELS = {
+    'AUTO_DETECT': sensor.sensor_ns.DHT_MODEL_AUTO_DETECT,
+    'DHT11': sensor.sensor_ns.DHT_MODEL_DHT11,
+    'DHT22': sensor.sensor_ns.DHT_MODEL_DHT22,
+    'AM2302': sensor.sensor_ns.DHT_MODEL_AM2302,
+    'RHT03': sensor.sensor_ns.DHT_MODEL_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,
+    cv.GenerateID('dht_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_PIN): GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_MODEL): vol.All(vol.Upper, cv.one_of(*DHT_MODELS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
 })
 
+MakeDHTSensor = Application.MakeDHTSensor
+
 
 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)
+    pin = gpio_output_pin_expression(config[CONF_PIN])
+    rhs = App.make_dht_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                              config[CONF_HUMIDITY][CONF_NAME],
+                              pin, config.get(CONF_UPDATE_INTERVAL))
+    dht = variable(MakeDHTSensor, config[CONF_MAKE_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])
+        constant = DHT_MODELS[config[CONF_MODEL]]
+        add(dht.Pdht.set_dht_model(constant))
+
+    sensor.setup_sensor(dht.Pdht.Pget_temperature_sensor(),
+                        dht.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pdht.Pget_humidity_sensor(),
+                        dht.Pmqtt_humidity, config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_DHT_SENSOR'

esphomeyaml/components/sensor/dht12.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('dht_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+})
+
+MakeDHT12Sensor = Application.MakeDHT12Sensor
+
+
+def to_code(config):
+    rhs = App.make_dht12_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                config[CONF_HUMIDITY][CONF_NAME],
+                                config.get(CONF_UPDATE_INTERVAL))
+    dht = variable(MakeDHT12Sensor, config[CONF_MAKE_ID], rhs)
+
+    sensor.setup_sensor(dht.Pdht.Pget_temperature_sensor(), dht.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pdht.Pget_humidity_sensor(), dht.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_DHT12_SENSOR'

esphomeyaml/components/sensor/hdc1080.py

@@ -2,25 +2,32 @@ 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, \
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, variable
+from esphomeyaml.helpers import App, variable, Application
 
 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,
+    cv.GenerateID('hdc1080_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
 })
 
+MakeHDC1080Sensor = Application.MakeHDC1080Sensor
+
 
 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])
+    hdc1080 = variable(MakeHDC1080Sensor, config[CONF_MAKE_ID], rhs)
+
+    sensor.setup_sensor(hdc1080.Phdc1080.Pget_temperature_sensor(), hdc1080.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(hdc1080.Phdc1080.Pget_humidity_sensor(), hdc1080.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_HDC1080_SENSOR'

esphomeyaml/components/sensor/htu21d.py

@@ -2,25 +2,31 @@ 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, \
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, variable
+from esphomeyaml.helpers import App, variable, Application
 
 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,
+    cv.GenerateID('htu21d', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
 })
 
+MakeHTU21DSensor = Application.MakeHTU21DSensor
+
 
 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])
+    htu21d = variable(MakeHTU21DSensor, config[CONF_MAKE_ID], rhs)
+    sensor.setup_sensor(htu21d.Phtu21d.Pget_temperature_sensor(), htu21d.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(htu21d.Phtu21d.Pget_humidity_sensor(), htu21d.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_HTU21D_SENSOR'

esphomeyaml/components/sensor/max6675.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_MAKE_ID, CONF_NAME, CONF_PIN_CLOCK, CONF_PIN_CS, CONF_PIN_MISO, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, gpio_input_pin_expression, \
+    gpio_output_pin_expression, variable
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('max6675', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_PIN_CS): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN_CLOCK): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Optional(CONF_PIN_MISO): pins.GPIO_INPUT_PIN_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeMAX6675Sensor = Application.MakeMAX6675Sensor
+
+
+def to_code(config):
+    pin_cs = gpio_output_pin_expression(config[CONF_PIN_CS])
+    pin_clock = gpio_output_pin_expression(config[CONF_PIN_CLOCK])
+    pin_miso = gpio_input_pin_expression(config[CONF_PIN_MISO])
+    rhs = App.make_max6675_sensor(config[CONF_NAME], pin_cs, pin_clock, pin_miso,
+                                  config.get(CONF_UPDATE_INTERVAL))
+    make = variable(MakeMAX6675Sensor, config[CONF_MAKE_ID], rhs)
+    sensor.setup_sensor(make.Pmax6675, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX6675_SENSOR'

esphomeyaml/components/sensor/mpu6050.py

@@ -0,0 +1,79 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_MQTT_ID, CONF_NAME, \
+    CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Pvariable
+
+DEPENDENCIES = ['i2c']
+
+CONF_ACCEL_X = 'accel_x'
+CONF_ACCEL_Y = 'accel_y'
+CONF_ACCEL_Z = 'accel_z'
+CONF_GYRO_X = 'gyro_x'
+CONF_GYRO_Y = 'gyro_y'
+CONF_GYRO_Z = 'gyro_z'
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('mpu6050', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_ADDRESS, default=0x68): cv.i2c_address,
+    vol.Optional(CONF_ACCEL_X): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_ACCEL_Y): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_ACCEL_Z): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_GYRO_X): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_GYRO_Y): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_GYRO_Z): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}), cv.has_at_least_one_key(CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z,
+                            CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z))
+
+MPU6050Component = sensor.sensor_ns.MPU6050Component
+MPU6050AccelSensor = sensor.sensor_ns.MPU6050AccelSensor
+MPU6050GyroSensor = sensor.sensor_ns.MPU6050GyroSensor
+MPU6050TemperatureSensor = sensor.sensor_ns.MPU6050TemperatureSensor
+
+
+def to_code(config):
+    rhs = App.make_mpu6050_sensor(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    mpu = Pvariable(MPU6050Component, config[CONF_MAKE_ID], rhs)
+    if CONF_ACCEL_X in config:
+        conf = config[CONF_ACCEL_X]
+        rhs = mpu.Pmake_accel_x_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050AccelSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+    if CONF_ACCEL_Y in config:
+        conf = config[CONF_ACCEL_Y]
+        rhs = mpu.Pmake_accel_y_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050AccelSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+    if CONF_ACCEL_Z in config:
+        conf = config[CONF_ACCEL_Z]
+        rhs = mpu.Pmake_accel_z_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050AccelSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+    if CONF_GYRO_X in config:
+        conf = config[CONF_GYRO_X]
+        rhs = mpu.Pmake_gyro_x_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050GyroSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+    if CONF_GYRO_Y in config:
+        conf = config[CONF_GYRO_Y]
+        rhs = mpu.Pmake_gyro_y_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050GyroSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+    if CONF_GYRO_Z in config:
+        conf = config[CONF_GYRO_Z]
+        rhs = mpu.Pmake_gyro_z_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050GyroSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        rhs = mpu.Pmake_temperature_sensor(conf[CONF_NAME])
+        sensor_ = Pvariable(MPU6050TemperatureSensor, conf[CONF_MQTT_ID], rhs)
+        sensor.register_sensor(sensor_, conf)
+
+
+BUILD_FLAGS = '-DUSE_MPU6050'

esphomeyaml/components/sensor/pulse_counter.py

@@ -3,32 +3,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_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
-    CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
+from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_INTERNAL_FILTER, \
+    CONF_MAKE_ID, CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
     ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, RawExpression, add, variable
+from esphomeyaml.helpers import App, add, global_ns, variable, Application
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
 GPIO_PULL_MODES = {
-    'PULLUP': 'GPIO_PULLUP_ONLY',
-    'PULLDOWN': 'GPIO_PULLDOWN_ONLY',
-    'PULLUP_PULLDOWN': 'GPIO_PULLUP_PULLDOWN',
-    'FLOATING': 'GPIO_FLOATING',
+    'PULLUP': global_ns.GPIO_PULLUP_ONLY,
+    'PULLDOWN': global_ns.GPIO_PULLDOWN_ONLY,
+    'PULLUP_PULLDOWN': global_ns.GPIO_PULLUP_PULLDOWN,
+    'FLOATING': global_ns.GPIO_FLOATING,
 }
 
-GPIO_PULL_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(GPIO_PULL_MODES.keys())))
+GPIO_PULL_MODE_SCHEMA = vol.All(vol.Upper, cv.one_of(*GPIO_PULL_MODES))
 
 COUNT_MODES = {
-    'DISABLE': 'PCNT_COUNT_DIS',
-    'INCREMENT': 'PCNT_COUNT_INC',
-    'DECREMENT': 'PCNT_COUNT_DEC',
+    'DISABLE': global_ns.PCNT_COUNT_DIS,
+    'INCREMENT': global_ns.PCNT_COUNT_INC,
+    'DECREMENT': global_ns.PCNT_COUNT_DEC,
 }
 
-COUNT_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(COUNT_MODES.keys())))
+COUNT_MODE_SCHEMA = vol.All(vol.Upper, cv.one_of(*COUNT_MODES))
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('pulse_counter'): cv.register_variable_id,
+    cv.GenerateID('pulse_counter', CONF_MAKE_ID): 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({
@@ -36,23 +36,28 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
         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)
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakePulseCounterSensor = Application.MakePulseCounterSensor
 
 
 def to_code(config):
-    rhs = App.make_pulse_counter_sensor(config[CONF_PIN], config[CONF_NAME],
+    rhs = App.make_pulse_counter_sensor(config[CONF_NAME], config[CONF_PIN],
                                         config.get(CONF_UPDATE_INTERVAL))
-    make = variable('Application::MakePulseCounter', config[CONF_ID], rhs)
+    make = variable(MakePulseCounterSensor, config[CONF_MAKE_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)))
+        add(pcnt.set_pull_mode(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)))
+        add(pcnt.set_edge_mode(rising_edge, falling_edge))
     if CONF_INTERNAL_FILTER in config:
         add(pcnt.set_filter(config[CONF_INTERNAL_FILTER]))
-    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)
+    sensor.setup_sensor(make.Ppcnt, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_PULSE_COUNTER_SENSOR'

esphomeyaml/components/sensor/rotary_encoder.py

@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_RESOLUTION
+from esphomeyaml.helpers import App, Application, add, gpio_input_pin_expression, variable
+
+RESOLUTIONS = {
+    '1': sensor.sensor_ns.ROTARY_ENCODER_1_PULSE_PER_CYCLE,
+    '2': sensor.sensor_ns.ROTARY_ENCODER_2_PULSES_PER_CYCLE,
+    '4': sensor.sensor_ns.ROTARY_ENCODER_4_PULSES_PER_CYCLE,
+}
+
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_RESET = 'pin_reset'
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('rotary_encoder', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_PIN_A): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN_B): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Optional(CONF_PIN_RESET): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Optional(CONF_RESOLUTION): vol.All(cv.string, cv.one_of(*RESOLUTIONS)),
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeRotaryEncoderSensor = Application.MakeRotaryEncoderSensor
+
+
+def to_code(config):
+    pin_a = gpio_input_pin_expression(config[CONF_PIN_A])
+    pin_b = gpio_input_pin_expression(config[CONF_PIN_B])
+    rhs = App.make_rotary_encoder_sensor(config[CONF_NAME], pin_a, pin_b)
+    make = variable(MakeRotaryEncoderSensor, config[CONF_MAKE_ID], rhs)
+    encoder = make.Protary_encoder
+    if CONF_PIN_RESET in config:
+        pin_i = gpio_input_pin_expression(config[CONF_PIN_RESET])
+        add(encoder.set_reset_pin(pin_i))
+    if CONF_RESOLUTION in config:
+        resolution = RESOLUTIONS[config[CONF_RESOLUTION]]
+        add(encoder.set_resolution(resolution))
+    sensor.setup_sensor(encoder, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_ROTARY_ENCODER_SENSOR'

esphomeyaml/components/sensor/sht3xd.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ACCURACY, CONF_ADDRESS, CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+SHT_ACCURACIES = {
+    'LOW': sensor.sensor_ns.SHT3XD_ACCURACY_LOW,
+    'MEDIUM': sensor.sensor_ns.SHT3XD_ACCURACY_MEDIUM,
+    'HIGH': sensor.sensor_ns.SHT3XD_ACCURACY_HIGH,
+}
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('sht3xd', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): sensor.SENSOR_SCHEMA,
+    vol.Optional(CONF_ADDRESS, default=0x44): cv.i2c_address,
+    vol.Optional(CONF_ACCURACY): vol.All(vol.Upper, cv.one_of(*SHT_ACCURACIES)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+})
+
+MakeSHT3XDSensor = Application.MakeSHT3XDSensor
+
+
+def to_code(config):
+    rhs = App.make_sht3xd_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    sht3xd = variable(MakeSHT3XDSensor, config[CONF_MAKE_ID], rhs)
+
+    if CONF_ACCURACY in config:
+        add(sht3xd.Psht3xd.set_accuracy(SHT_ACCURACIES[config[CONF_ACCURACY]]))
+
+    sensor.setup_sensor(sht3xd.Psht3xd.Pget_temperature_sensor(), sht3xd.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(sht3xd.Psht3xd.Pget_humidity_sensor(), sht3xd.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_SHT3XD'

esphomeyaml/components/sensor/template.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, process_lambda, variable, Application
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('template_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeTemplateSensor = Application.MakeTemplateSensor
+
+
+def to_code(config):
+    template_ = process_lambda(config[CONF_LAMBDA], [])
+    rhs = App.make_template_sensor(config[CONF_NAME], template_,
+                                   config.get(CONF_UPDATE_INTERVAL))
+    make = variable(MakeTemplateSensor, config[CONF_MAKE_ID], rhs)
+    sensor.setup_sensor(make.Ptemplate_, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SENSOR'

esphomeyaml/components/sensor/tsl2561.py

@@ -0,0 +1,57 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_GAIN, CONF_INTEGRATION_TIME, CONF_MAKE_ID, \
+    CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+INTEGRATION_TIMES = {
+    14: sensor.sensor_ns.TSL2561_INTEGRATION_14MS,
+    101: sensor.sensor_ns.TSL2561_INTEGRATION_101MS,
+    402: sensor.sensor_ns.TSL2561_INTEGRATION_402MS,
+}
+GAINS = {
+    '1X': sensor.sensor_ns.TSL2561_GAIN_1X,
+    '16X': sensor.sensor_ns.TSL2561_GAIN_16X,
+}
+
+CONF_IS_CS_PACKAGE = 'is_cs_package'
+
+
+def validate_integration_time(value):
+    value = cv.positive_time_period_milliseconds(value).total_milliseconds
+    if value not in INTEGRATION_TIMES:
+        raise vol.Invalid(u"Unsupported integration time {}.".format(value))
+    return value
+
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('tsl2561_sensor', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_ADDRESS, default=0x39): cv.i2c_address,
+    vol.Optional(CONF_INTEGRATION_TIME): validate_integration_time,
+    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*GAINS)),
+    vol.Optional(CONF_IS_CS_PACKAGE): cv.boolean,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeTSL2561Sensor = Application.MakeTSL2561Sensor
+
+
+def to_code(config):
+    rhs = App.make_tsl2561_sensor(config[CONF_NAME], config[CONF_ADDRESS],
+                                  config.get(CONF_UPDATE_INTERVAL))
+    make_tsl = variable(MakeTSL2561Sensor, config[CONF_MAKE_ID], rhs)
+    tsl2561 = make_tsl.Ptsl2561
+    if CONF_INTEGRATION_TIME in config:
+        add(tsl2561.set_integration_time(INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
+    if CONF_GAIN in config:
+        add(tsl2561.set_gain(GAINS[config[CONF_GAIN]]))
+    if CONF_IS_CS_PACKAGE in config:
+        add(tsl2561.set_is_cs_package(config[CONF_IS_CS_PACKAGE]))
+    sensor.setup_sensor(tsl2561, make_tsl.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_TSL2561'

esphomeyaml/components/sensor/ultrasonic.py

@@ -3,30 +3,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_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
+from esphomeyaml.const import CONF_ECHO_PIN, CONF_MAKE_ID, CONF_NAME, CONF_TIMEOUT_METER, \
+    CONF_TIMEOUT_TIME, CONF_TRIGGER_PIN, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, gpio_input_pin_expression, \
+    gpio_output_pin_expression, variable
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('ultrasonic'): cv.register_variable_id,
+    cv.GenerateID('ultrasonic', CONF_MAKE_ID): 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.Required(CONF_ECHO_PIN): pins.GPIO_INTERNAL_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)
+    vol.Exclusive(CONF_TIMEOUT_TIME, 'timeout'): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(sensor.SENSOR_SCHEMA.schema)
+
+MakeUltrasonicSensor = Application.MakeUltrasonicSensor
 
 
 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],
+    trigger = gpio_output_pin_expression(config[CONF_TRIGGER_PIN])
+    echo = gpio_input_pin_expression(config[CONF_ECHO_PIN])
+    rhs = App.make_ultrasonic_sensor(config[CONF_NAME], trigger, echo,
                                      config.get(CONF_UPDATE_INTERVAL))
-    make = variable('Application::MakeUltrasonicSensor', config[CONF_ID], rhs)
+    make = variable(MakeUltrasonicSensor, config[CONF_MAKE_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)
+    sensor.setup_sensor(ultrasonic, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_ULTRASONIC_SENSOR'

esphomeyaml/components/switch/__init__.py

@@ -1,25 +1,50 @@
 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
+from esphomeyaml.const import CONF_ICON, CONF_ID, CONF_INVERTED, CONF_MQTT_ID
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, setup_mqtt_component
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-MQTT_SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID('switch_'): cv.register_variable_id,
+    cv.GenerateID('mqtt_switch', CONF_MQTT_ID): cv.register_variable_id,
     vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_INVERTED): cv.boolean,
 })
 
+switch_ns = esphomelib_ns.namespace('switch_')
+Switch = switch_ns.Switch
+MQTTSwitchComponent = switch_ns.MQTTSwitchComponent
+ToggleAction = switch_ns.ToggleAction
+TurnOffAction = switch_ns.TurnOffAction
+TurnOnAction = switch_ns.TurnOnAction
 
-def setup_mqtt_switch(obj, config):
+
+def setup_switch_core_(switch_var, mqtt_var, config):
     if CONF_ICON in config:
-        add(obj.set_icon(config[CONF_ICON]))
-    setup_mqtt_component(obj, config)
+        add(switch_var.set_icon(config[CONF_ICON]))
+    if CONF_INVERTED in config:
+        add(switch_var.set_inverted(config[CONF_INVERTED]))
+
+    setup_mqtt_component(mqtt_var, 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)
+def setup_switch(switch_obj, mqtt_obj, config):
+    switch_var = Pvariable(Switch, config[CONF_ID], switch_obj, has_side_effects=False)
+    mqtt_var = Pvariable(MQTTSwitchComponent, config[CONF_MQTT_ID], mqtt_obj,
+                         has_side_effects=False)
+    setup_switch_core_(switch_var, mqtt_var, config)
+
+
+def register_switch(var, config):
+    switch_var = Pvariable(Switch, config[CONF_ID], var, has_side_effects=True)
+    rhs = App.register_switch(switch_var)
+    mqtt_var = Pvariable(MQTTSwitchComponent, config[CONF_MQTT_ID], rhs,
+                         has_side_effects=True)
+    setup_switch_core_(switch_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SWITCH'

esphomeyaml/components/switch/gpio.py

@@ -3,16 +3,21 @@ 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
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, Application, gpio_output_pin_expression, variable
 
 PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('gpio_switch'): cv.register_variable_id,
+    cv.GenerateID('gpio_switch', CONF_MAKE_ID): cv.register_variable_id,
     vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+}).extend(switch.SWITCH_SCHEMA.schema)
+
+MakeGPIOSwitch = Application.MakeGPIOSwitch
 
 
 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)
+    rhs = App.make_gpio_switch(config[CONF_NAME], gpio_output_pin_expression(config[CONF_PIN]))
+    gpio = variable(MakeGPIOSwitch, config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(gpio.Pswitch_, gpio.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_SWITCH'

esphomeyaml/components/switch/ir_transmitter.py

@@ -2,15 +2,22 @@ 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.components.ir_transmitter import IRTransmitterComponent
+from esphomeyaml.const import CONF_ADDRESS, CONF_CARRIER_FREQUENCY, CONF_COMMAND, CONF_DATA, \
+    CONF_INVERTED, CONF_IR_TRANSMITTER_ID, CONF_LG, CONF_NAME, CONF_NBITS, CONF_NEC, \
+    CONF_PANASONIC, CONF_RAW, CONF_REPEAT, CONF_SONY, CONF_TIMES, CONF_WAIT_TIME
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import HexIntLiteral, MockObj, get_variable, ArrayInitializer
+from esphomeyaml.helpers import App, ArrayInitializer, HexIntLiteral, get_variable
 
-PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('ir_transmitter'): cv.register_variable_id,
+DEPENDENCIES = ['ir_transmitter']
+
+IR_KEYS = [CONF_NEC, CONF_LG, CONF_SONY, CONF_PANASONIC, CONF_RAW]
+
+WAIT_TIME_MESSAGE = "The wait_time_us option has been renamed to wait_time in order to decrease " \
+                    "ambiguity. "
+
+PLATFORM_SCHEMA = vol.All(switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('ir_transmitter_switch'): 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,
@@ -33,14 +40,18 @@ PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
     }),
     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.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds,
+
+        vol.Optional('wait_time_us'): cv.invalid(WAIT_TIME_MESSAGE),
     })),
     vol.Optional(CONF_IR_TRANSMITTER_ID): cv.variable_id,
-}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
-
+    vol.Optional(CONF_INVERTED): cv.invalid("IR Transmitters do not support inverted mode!"),
+}).extend(switch.SWITCH_SCHEMA.schema), cv.has_at_least_one_key(*IR_KEYS))
 
 # pylint: disable=invalid-name
-SendData = MockObj('switch_::ir::SendData', '::')
+ir_ns = switch.switch_ns.namespace('ir')
+SendData = ir_ns.namespace('SendData')
+DataTransmitter = IRTransmitterComponent.DataTransmitter
 
 
 def safe_hex(value):
@@ -77,13 +88,16 @@ def exp_send_data(config):
             wait_us = None
         else:
             times = config[CONF_REPEAT][CONF_TIMES]
-            wait_us = config[CONF_REPEAT][CONF_WAIT_TIME_US]
-        base = MockObj(unicode(base), u'.')
+            wait_us = config[CONF_REPEAT][CONF_WAIT_TIME]
         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)
+    ir = get_variable(config.get(CONF_IR_TRANSMITTER_ID), IRTransmitterComponent)
     send_data = exp_send_data(config)
-    switch.make_mqtt_switch_for(ir.create_transmitter(send_data), config)
+    rhs = App.register_component(ir.create_transmitter(config[CONF_NAME], send_data))
+    switch.register_switch(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_IR_TRANSMITTER'

esphomeyaml/components/switch/output.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphomeyaml.helpers import App, Application, get_variable, variable
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('output_switch', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Required(CONF_OUTPUT): cv.variable_id,
+}).extend(switch.SWITCH_SCHEMA.schema)
+
+MakeSimpleSwitch = Application.MakeSimpleSwitch
+
+
+def to_code(config):
+    output = get_variable(config[CONF_OUTPUT])
+    rhs = App.make_simple_switch(config[CONF_NAME], output)
+    gpio = variable(MakeSimpleSwitch, config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(gpio.Pswitch_, gpio.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_SIMPLE_SWITCH'

esphomeyaml/components/switch/restart.py

@@ -1,14 +1,22 @@
+import voluptuous as vol
+
 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
+from esphomeyaml.const import CONF_INVERTED, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable
 
 PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('restart_switch'): cv.register_variable_id,
-}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+    cv.GenerateID('restart_switch', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_INVERTED): cv.invalid("Restart switches do not support inverted mode!"),
+}).extend(switch.SWITCH_SCHEMA.schema)
+
+MakeRestartSwitch = Application.MakeRestartSwitch
 
 
 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)
+    restart = variable(MakeRestartSwitch, config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(restart.Prestart, restart.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_RESTART_SWITCH'

esphomeyaml/components/switch/shutdown.py

@@ -0,0 +1,22 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_INVERTED, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('shutdown_switch', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_INVERTED): cv.invalid("Shutdown switches do not support inverted mode!"),
+}).extend(switch.SWITCH_SCHEMA.schema)
+
+MakeShutdownSwitch = Application.MakeShutdownSwitch
+
+
+def to_code(config):
+    rhs = App.make_shutdown_switch(config[CONF_NAME])
+    shutdown = variable(MakeShutdownSwitch, config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(shutdown.Pshutdown, shutdown.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_SHUTDOWN_SWITCH'

esphomeyaml/components/switch/template.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import automation
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_TURN_OFF_ACTION, \
+    CONF_TURN_ON_ACTION, CONF_OPTIMISTIC
+from esphomeyaml.helpers import App, Application, process_lambda, variable, NoArg, add
+
+PLATFORM_SCHEMA = vol.All(switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('template_switch', CONF_MAKE_ID): cv.register_variable_id,
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_TURN_OFF_ACTION): automation.ACTIONS_SCHEMA,
+    vol.Optional(CONF_TURN_ON_ACTION): automation.ACTIONS_SCHEMA,
+}).extend(switch.SWITCH_SCHEMA.schema), cv.has_at_exactly_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
+
+MakeTemplateSwitch = Application.MakeTemplateSwitch
+
+
+def to_code(config):
+    rhs = App.make_template_switch(config[CONF_NAME])
+    make = variable(MakeTemplateSwitch, config[CONF_MAKE_ID], rhs)
+
+    if CONF_LAMBDA in config:
+        template_ = process_lambda(config[CONF_LAMBDA], [])
+        add(make.Ptemplate.set_state_lambda(template_))
+    if CONF_TURN_OFF_ACTION in config:
+        actions = automation.build_actions(config[CONF_TURN_OFF_ACTION], NoArg)
+        add(make.Ptemplate_.add_turn_off_actions(actions))
+    if CONF_TURN_ON_ACTION in config:
+        actions = automation.build_actions(config[CONF_TURN_ON_ACTION], NoArg)
+        add(make.Ptemplate_.add_turn_on_actions(actions))
+    if CONF_OPTIMISTIC in config:
+        add(make.Ptemplate_.set_optimistic(config[CONF_OPTIMISTIC]))
+
+    switch.setup_switch(make.Ptemplate_, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SWITCH'

esphomeyaml/components/web_server.py

@@ -0,0 +1,37 @@
+import logging
+
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import core
+from esphomeyaml.const import CONF_PORT, CONF_JS_URL, CONF_CSS_URL, CONF_ID, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, add, Pvariable, esphomelib_ns
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID('web_server'): cv.register_variable_id,
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Optional(CONF_CSS_URL): vol.Url,
+    vol.Optional(CONF_JS_URL): vol.Url,
+})
+
+WebServer = esphomelib_ns.WebServer
+
+
+def to_code(config):
+    rhs = App.init_web_server(config.get(CONF_PORT))
+    web_server = Pvariable(WebServer, config[CONF_ID], rhs)
+    if CONF_CSS_URL in config:
+        add(web_server.set_css_url(config[CONF_CSS_URL]))
+    if CONF_JS_URL in config:
+        add(web_server.set_js_url(config[CONF_JS_URL]))
+
+
+BUILD_FLAGS = '-DUSE_WEB_SERVER'
+
+
+def lib_deps(config):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return 'FS'
+    return ''

esphomeyaml/components/wifi.py

@@ -1,27 +1,54 @@
 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
+from esphomeyaml import core
+from esphomeyaml.const import CONF_AP, CONF_CHANNEL, CONF_DNS1, CONF_DNS2, CONF_DOMAIN, \
+    CONF_GATEWAY, CONF_HOSTNAME, CONF_ID, CONF_MANUAL_IP, CONF_PASSWORD, CONF_SSID, \
+    CONF_STATIC_IP, CONF_SUBNET, ESP_PLATFORM_ESP8266
+from esphomeyaml.helpers import App, Pvariable, StructInitializer, add, esphomelib_ns, global_ns
 
-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,
+
+def validate_password(value):
+    value = cv.string(value)
+    if not value:
+        return value
+    if len(value) < 8:
+        raise vol.Invalid(u"WPA password must be at least 8 characters long")
+    if len(value) > 63:
+        raise vol.Invalid(u"WPA password must be at most 63 characters long")
+    return value
+
+
+AP_MANUAL_IP_SCHEMA = vol.Schema({
+    vol.Required(CONF_STATIC_IP): cv.ipv4,
+    vol.Required(CONF_GATEWAY): cv.ipv4,
+    vol.Required(CONF_SUBNET): cv.ipv4,
 })
 
+STA_MANUAL_IP_SCHEMA = AP_MANUAL_IP_SCHEMA.extend({
+    vol.Inclusive(CONF_DNS1, 'dns'): cv.ipv4,
+    vol.Inclusive(CONF_DNS2, 'dns'): cv.ipv4,
+})
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID('wifi'): cv.register_variable_id,
+    vol.Optional(CONF_SSID): cv.ssid,
+    vol.Optional(CONF_PASSWORD): validate_password,
+    vol.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
+    vol.Optional(CONF_AP): vol.Schema({
+        vol.Required(CONF_SSID): cv.ssid,
+        vol.Optional(CONF_PASSWORD): validate_password,
+        vol.Optional(CONF_CHANNEL): vol.All(cv.positive_int, vol.Range(min=1, max=14)),
+        vol.Optional(CONF_MANUAL_IP): AP_MANUAL_IP_SCHEMA,
+    }),
+    vol.Optional(CONF_HOSTNAME): cv.hostname,
+    vol.Required(CONF_DOMAIN, default='.local'): cv.domainname,
+})
 
 # pylint: disable=invalid-name
-IPAddress = MockObj('IPAddress')
+IPAddress = global_ns.IPAddress
+ManualIP = esphomelib_ns.ManualIP
+WiFiComponent = esphomelib_ns.WiFiComponent
 
 
 def safe_ip(ip):
@@ -30,19 +57,44 @@ def safe_ip(ip):
     return IPAddress(*ip.args)
 
 
+def manual_ip(config):
+    return StructInitializer(
+        ManualIP,
+        ('static_ip', safe_ip(config[CONF_STATIC_IP])),
+        ('gateway', safe_ip(config[CONF_GATEWAY])),
+        ('subnet', safe_ip(config[CONF_SUBNET])),
+        ('dns1', safe_ip(config.get(CONF_DNS1))),
+        ('dns2', safe_ip(config.get(CONF_DNS2))),
+    )
+
+
 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))
+    sta = CONF_SSID in config
+    ap = CONF_AP in config
+    if sta:
+        rhs = App.init_wifi(config[CONF_SSID], config.get(CONF_PASSWORD))
+    else:
+        rhs = App.init_wifi()
+    wifi = Pvariable(WiFiComponent, config[CONF_ID], rhs)
+
+    if sta and CONF_MANUAL_IP in config:
+        add(wifi.set_sta_manual_ip(manual_ip(config[CONF_MANUAL_IP])))
+
+    if ap:
+        conf = config[CONF_AP]
+        password = config.get(CONF_PASSWORD)
+        if password is None and CONF_CHANNEL in conf:
+            password = u""
+        add(wifi.set_ap(conf[CONF_SSID], password, conf.get(CONF_CHANNEL)))
+
+        if CONF_MANUAL_IP in conf:
+            add(wifi.set_ap_manual_ip(manual_ip(conf[CONF_MANUAL_IP])))
+
     if CONF_HOSTNAME in config:
         add(wifi.set_hostname(config[CONF_HOSTNAME]))
+
+
+def lib_deps(config):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+        return 'ESP8266WiFi'
+    return None

esphomeyaml/config.json

@@ -0,0 +1,23 @@
+{
+  "name": "esphomeyaml",
+  "version": "1.6.0",
+  "slug": "esphomeyaml",
+  "description": "esphomeyaml HassIO add-on for intelligently managing all your ESP8266/ESP32 devices.",
+  "url": "https://esphomelib.com/esphomeyaml/index.html",
+  "startup": "application",
+  "webui": "http://[HOST]:[PORT:6052]",
+  "boot": "auto",
+  "ports": {
+    "6052/tcp": 6052,
+    "6053/tcp": 6053
+  },
+  "auto_uart": true,
+  "map": [
+    "config:rw"
+  ],
+  "options": {},
+  "environment": {
+    "ESPHOMEYAML_OTA_HOST_PORT": "6053"
+  },
+  "schema": {}
+}

esphomeyaml/config.py

@@ -8,29 +8,32 @@ 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 import core, yaml_util
+from esphomeyaml.const import CONF_BOARD, CONF_BOARD_FLASH_MODE, CONF_ESPHOMEYAML, \
+    CONF_LIBRARY_URI, \
+    CONF_NAME, CONF_PLATFORM, CONF_SIMPLIFY, CONF_USE_BUILD_FLAGS, CONF_WIFI, ESP_PLATFORMS, \
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, add, add_task, color
+from esphomeyaml.helpers import App, add, color
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_LIBRARY_URI = u'esphomelib@1.2.1'
+DEFAULT_LIBRARY_URI = u'https://github.com/OttoWinter/esphomelib.git#v1.6.0'
+
+BUILD_FLASH_MODES = ['qio', 'qout', 'dio', 'dout']
 
 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_PLATFORM): cv.string,
     vol.Required(CONF_BOARD): cv.string,
     vol.Optional(CONF_LIBRARY_URI, default=DEFAULT_LIBRARY_URI): cv.string,
     vol.Optional(CONF_SIMPLIFY, default=True): cv.boolean,
+    vol.Optional(CONF_USE_BUILD_FLAGS, default=True): cv.boolean,
+    vol.Optional(CONF_BOARD_FLASH_MODE): vol.All(vol.Lower, cv.one_of(*BUILD_FLASH_MODES)),
 })
 
 REQUIRED_COMPONENTS = [
-    CONF_ESPHOMEYAML, CONF_WIFI, CONF_MQTT
+    CONF_ESPHOMEYAML, CONF_WIFI
 ]
 
 _COMPONENT_CACHE = {}
@@ -66,8 +69,17 @@ def is_platform_component(component):
     return hasattr(component, 'PLATFORM_SCHEMA')
 
 
-def validate_schema(config, schema):
-    return schema(config)
+def iter_components(config):
+    for domain, conf in config.iteritems():
+        if domain == CONF_ESPHOMEYAML:
+            continue
+        component = get_component(domain)
+        yield domain, component, conf
+        if is_platform_component(component):
+            for p_config in conf:
+                p_name = u"{}.{}".format(domain, p_config[CONF_PLATFORM])
+                platform = get_component(p_name)
+                yield p_name, platform, p_config
 
 
 class Config(OrderedDict):
@@ -96,7 +108,7 @@ def validate_config(config):
         result.add_error(_format_config_error(ex, domain, config), domain, config)
 
     try:
-        result[CONF_ESPHOMEYAML] = validate_schema(config[CONF_ESPHOMEYAML], CORE_SCHEMA)
+        result[CONF_ESPHOMEYAML] = CORE_SCHEMA(config[CONF_ESPHOMEYAML])
     except vol.Invalid as ex:
         _comp_error(ex, CONF_ESPHOMEYAML, config)
 
@@ -111,8 +123,8 @@ def validate_config(config):
             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))
+        if core.ESP_PLATFORM not in esp_platforms:
+            result.add_error(u"Component {} doesn't support {}.".format(domain, core.ESP_PLATFORM))
             continue
 
         success = True
@@ -129,7 +141,7 @@ def validate_config(config):
                 validated = component.CONFIG_SCHEMA(conf)
                 result[domain] = validated
             except vol.Invalid as ex:
-                _comp_error(ex, domain, config)
+                _comp_error(ex, domain, conf)
                 continue
 
         if not hasattr(component, 'PLATFORM_SCHEMA'):
@@ -138,7 +150,7 @@ def validate_config(config):
         platforms = []
         for p_config in conf:
             if not isinstance(p_config, dict):
-                result.add_error(u"Platform schemas mus have 'platform:' key")
+                result.add_error(u"Platform schemas must have 'platform:' key")
                 continue
             p_name = p_config.get(u'platform')
             if p_name is None:
@@ -149,6 +161,22 @@ def validate_config(config):
                 result.add_error(u"Platform not found: {}.{}")
                 continue
 
+            success = True
+            dependencies = getattr(platform, 'DEPENDENCIES', [])
+            for dependency in dependencies:
+                if dependency not in _ALL_COMPONENTS:
+                    result.add_error(u"Platform {}.{} requires {}".format(domain, p_name,
+                                                                          dependency))
+                    success = False
+            if not success:
+                continue
+
+            esp_platforms = getattr(platform, 'ESP_PLATFORMS', ESP_PLATFORMS)
+            if core.ESP_PLATFORM not in esp_platforms:
+                result.add_error(
+                    u"Platform {}.{} doesn't support {}.".format(domain, p_name, core.ESP_PLATFORM))
+                continue
+
             if hasattr(platform, u'PLATFORM_SCHEMA'):
                 try:
                     p_validated = platform.PLATFORM_SCHEMA(p_config)
@@ -160,7 +188,7 @@ def validate_config(config):
     return result
 
 
-REQUIRED = ['esphomeyaml', 'wifi', 'mqtt']
+REQUIRED = ['esphomeyaml', 'wifi']
 
 
 def _format_config_error(ex, domain, config):
@@ -172,6 +200,9 @@ def _format_config_error(ex, domain, config):
     else:
         message += u'{}.'.format(humanize_error(config, ex))
 
+    if isinstance(config, list):
+        return message
+
     domain_config = config.get(domain, config)
     message += u" (See {}, line {}). ".format(
         getattr(domain_config, '__config_file__', '?'),
@@ -185,14 +216,24 @@ def load_config(path):
         config = yaml_util.load_yaml(path)
     except OSError:
         raise ESPHomeYAMLError(u"Could not read configuration file at {}".format(path))
+    core.RAW_CONFIG = config
 
-    esp_platform = unicode(config.get(CONF_ESPHOMEYAML, {}).get(CONF_PLATFORM, u""))
+    if CONF_ESPHOMEYAML not in config:
+        raise ESPHomeYAMLError(u"No esphomeyaml section in config")
+    core_conf = config[CONF_ESPHOMEYAML]
+    if CONF_PLATFORM not in core_conf:
+        raise ESPHomeYAMLError("esphomeyaml.platform not specified.")
+    esp_platform = unicode(core_conf[CONF_PLATFORM])
     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))
+    if '8266' in esp_platform:
+        esp_platform = ESP_PLATFORM_ESP8266
+    if '32' in esp_platform:
+        esp_platform = ESP_PLATFORM_ESP32
+    core.ESP_PLATFORM = esp_platform
+    if CONF_BOARD not in core_conf:
+        raise ESPHomeYAMLError("esphomeyaml.board not specified.")
+    core.BOARD = unicode(core_conf[CONF_BOARD])
+    core.SIMPLIFY = cv.boolean(core_conf.get(CONF_SIMPLIFY, True))
 
     try:
         result = validate_config(config)
@@ -203,28 +244,6 @@ def load_config(path):
     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__'):
@@ -263,8 +282,8 @@ def read_config(path):
     _LOGGER.debug("Reading configuration...")
     try:
         res = load_config(path)
-    except ESPHomeYAMLError as e:
-        _LOGGER.error(u"Error while reading config: %s", e)
+    except ESPHomeYAMLError as err:
+        _LOGGER.error(u"Error while reading config: %s", err)
         return None
     excepts = {}
     for err in res.errors:

esphomeyaml/config_validation.py

@@ -3,15 +3,17 @@
 from __future__ import print_function
 
 import logging
-from datetime import timedelta
+import re
 
 import voluptuous as vol
 
+from esphomeyaml import core
 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.core import HexInt, IPAddress, TimePeriod, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds, Lambda
 from esphomeyaml.helpers import ensure_unique_string
 
 _LOGGER = logging.getLogger(__name__)
@@ -24,10 +26,7 @@ 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_'
+ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyz0123456789_'
 
 RESERVED_IDS = [
     # C++ keywords http://en.cppreference.com/w/cpp/keyword
@@ -135,22 +134,39 @@ def 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)
+    value = string(value)
+    if not value:
+        raise vol.Invalid("ID must not be empty")
+    if value[0].isdigit():
+        raise vol.Invalid("First character in ID cannot be a digit.")
+    if '-' in value:
+        raise vol.Invalid("Dashes are not supported in IDs, please use underscores instead.")
+    for char in value:
+        if char != '_' and not char.isalnum():
+            raise vol.Invalid(u"IDs must only consist of upper/lowercase characters and numbers."
+                              u"The character '{}' cannot be used".format(char))
     if value in RESERVED_IDS:
         raise vol.Invalid(u"ID {} is reserved internally and cannot be used".format(value))
     return value
 
 
+def templatable(other_validators):
+    def validator(value):
+        if isinstance(value, Lambda):
+            return value
+        return other_validators(value)
+    return validator
+
+
 def only_on(platforms):
     if not isinstance(platforms, list):
         platforms = [platforms]
 
     def validator_(obj):
-        if ESP_PLATFORM not in platforms:
+        if core.ESP_PLATFORM not in platforms:
             raise vol.Invalid(u"This feature is only available on {}".format(platforms))
         return obj
 
@@ -171,90 +187,163 @@ def has_at_least_one_key(*keys):
         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)))
+        if not any(k in keys for k in obj):
+            raise vol.Invalid('Must contain at least one of {}.'.format(', '.join(keys)))
+        return obj
 
     return validate
 
 
-TIME_PERIOD_ERROR = "Time period {} should be format 5ms, 5s, 5min, 5h"
+def has_at_exactly_one_key(*keys):
+    def validate(obj):
+        if not isinstance(obj, dict):
+            raise vol.Invalid('expected dictionary')
+
+        number = sum(k in keys for k in obj)
+        if number > 1:
+            raise vol.Invalid("Cannot specify more than one of {}.".format(', '.join(keys)))
+        if number < 1:
+            raise vol.Invalid('Must contain exactly one of {}.'.format(', '.join(keys)))
+        return obj
+
+    return validate
+
+
+TIME_PERIOD_ERROR = "Time period {} should be format number + unit, for example 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),
+        'days': vol.Coerce(float),
+        'hours': vol.Coerce(float),
+        'minutes': vol.Coerce(float),
+        'seconds': vol.Coerce(float),
+        'milliseconds': vol.Coerce(float),
+        'microseconds': vol.Coerce(float),
     }),
     has_at_least_one_key('days', 'hours', 'minutes',
-                         'seconds', 'milliseconds'),
-    lambda value: timedelta(**value))
+                         'seconds', 'milliseconds', 'microseconds'),
+    lambda value: TimePeriod(**value))
 
 
-def time_period_str(value):
-    """Validate and transform time offset."""
+TIME_PERIOD_EXPLICIT_MESSAGE = ("The old way of being able to write time values without a "
+                                "time unit (like \"1000\" for 1000 milliseconds) has been "
+                                "removed in 1.5.0 as it was ambiguous in some places. Please "
+                                "now explicitly specify the time unit (like \"1000ms\"). See "
+                                "https://esphomelib.com/esphomeyaml/configuration-types.html#time "
+                                "for more information.")
+
+
+def time_period_str_colon(value):
+    """Validate and transform time offset with format HH:MM[:SS]."""
     if isinstance(value, int):
-        raise vol.Invalid("Make sure you wrap time values in quotes")
-    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid('Make sure you wrap time values in quotes')
+    elif not isinstance(value, str):
         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))
+        parsed = [int(x) for x in value.split(':')]
+    except ValueError:
+        raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+    if len(parsed) == 2:
+        hour, minute = parsed
+        second = 0
+    elif len(parsed) == 3:
+        hour, minute, second = parsed
+    else:
+        raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+    return TimePeriod(hours=hour, minutes=minute, seconds=second)
 
 
-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)
+def time_period_str_unit(value):
+    """Validate and transform time period with time unit and integer value."""
+    if isinstance(value, int):
+        value = str(value)
+    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid("Expected string for time period with unit.")
+
+    try:
+        float(value)
+    except ValueError:
+        pass
+    else:
+        raise vol.Invalid(TIME_PERIOD_EXPLICIT_MESSAGE)
+
+    unit_to_kwarg = {
+        'us': 'microseconds',
+        'microseconds': 'microseconds',
+        'ms': 'milliseconds',
+        'milliseconds': 'milliseconds',
+        's': 'seconds',
+        'sec': 'seconds',
+        'seconds': 'seconds',
+        'min': 'minutes',
+        'minutes': 'minutes',
+        'h': 'hours',
+        'hours': 'hours',
+        'd': 'days',
+        'days': 'days',
+    }
+
+    match = re.match(r"^([-+]?[0-9]*\.?[0-9]*)\s*(\w*)$", value)
+
+    if match is None or match.group(2) not in unit_to_kwarg:
+        raise vol.Invalid(u"Expected time period with unit, "
+                          u"got {}".format(value))
+
+    kwarg = unit_to_kwarg[match.group(2)]
+    return TimePeriod(**{kwarg: float(match.group(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))
+def time_period_in_milliseconds_(value):
+    if value.microseconds is not None and value.microseconds != 0:
+        raise vol.Invalid("Maximum precision is milliseconds")
+    return TimePeriodMilliseconds(**value.as_dict())
+
+
+def time_period_in_microseconds_(value):
+    return TimePeriodMicroseconds(**value.as_dict())
+
+
+def time_period_in_seconds_(value):
+    if value.microseconds is not None and value.microseconds != 0:
+        raise vol.Invalid("Maximum precision is seconds")
+    if value.milliseconds is not None and value.milliseconds != 0:
+        raise vol.Invalid("Maximum precision is seconds")
+    return TimePeriodSeconds(**value.as_dict())
+
+
+time_period = vol.Any(time_period_str_unit, time_period_str_colon, time_period_dict)
+positive_time_period = vol.All(time_period, vol.Range(min=TimePeriod()))
+positive_time_period_milliseconds = vol.All(positive_time_period, time_period_in_milliseconds_)
+positive_time_period_seconds = vol.All(positive_time_period, time_period_in_seconds_)
+positive_time_period_microseconds = vol.All(positive_time_period, time_period_in_microseconds_)
+positive_not_null_time_period = vol.All(time_period,
+                                        vol.Range(min=TimePeriod(), 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,
+    '': 1
 }
 
 
 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
+    value = string(value)
+    match = re.match(r"^([-+]?[0-9]*\.?[0-9]*)\s*(\w*?)(?:Hz|HZ|hz)?$", value)
+
+    if match is None:
+        raise vol.Invalid(u"Expected frequency with unit, "
+                          u"got {}".format(value))
+
+    mantissa = float(match.group(1))
+    if match.group(2) not in METRIC_SUFFIXES:
+        raise vol.Invalid(u"Invalid frequency suffix {}".format(match.group(2)))
+
+    multiplier = METRIC_SUFFIXES[match.group(2)]
+    return mantissa * multiplier
 
 
 def hostname(value):
@@ -267,6 +356,18 @@ def hostname(value):
     return value
 
 
+def domainname(value):
+    value = string(value)
+    if not value.startswith('.'):
+        raise vol.Invalid("Domainname must start with .")
+    if value.startswith('..'):
+        raise vol.Invalid("Domainname must start with single .")
+    for c in value:
+        if not (c.isalnum() or c in '._-'):
+            raise vol.Invalid("Domainname can only have alphanumeric characters and _ or -")
+    return value
+
+
 def ssid(value):
     if value is None:
         raise vol.Invalid("SSID can not be None")
@@ -274,8 +375,8 @@ def ssid(value):
         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")
+    if len(value) > 31:
+        raise vol.Invalid("SSID can't be longer than 31 characters")
     return value
 
 
@@ -296,15 +397,70 @@ def ipv4(value):
     return IPAddress(*parts_)
 
 
-def publish_topic(value):
-    value = string_strict(value)
-    if value.endswith('/'):
-        raise vol.Invalid("Publish topic can't end with '/'")
+def _valid_topic(value):
+    """Validate that this is a valid topic name/filter."""
+    if isinstance(value, dict):
+        raise vol.Invalid("Can't use dictionary with topic")
+    value = string(value)
+    try:
+        raw_value = value.encode('utf-8')
+    except UnicodeError:
+        raise vol.Invalid("MQTT topic name/filter must be valid UTF-8 string.")
+    if not raw_value:
+        raise vol.Invalid("MQTT topic name/filter must not be empty.")
+    if len(raw_value) > 65535:
+        raise vol.Invalid("MQTT topic name/filter must not be longer than "
+                          "65535 encoded bytes.")
+    if '\0' in value:
+        raise vol.Invalid("MQTT topic name/filter must not contain null "
+                          "character.")
     return value
 
 
-subscribe_topic = string_strict  # TODO improve this
-mqtt_payload = string  # TODO improve this
+def subscribe_topic(value):
+    """Validate that we can subscribe using this MQTT topic."""
+    value = _valid_topic(value)
+    for i in (i for i, c in enumerate(value) if c == '+'):
+        if (i > 0 and value[i - 1] != '/') or \
+                (i < len(value) - 1 and value[i + 1] != '/'):
+            raise vol.Invalid("Single-level wildcard must occupy an entire "
+                              "level of the filter")
+
+    index = value.find('#')
+    if index != -1:
+        if index != len(value) - 1:
+            # If there are multiple wildcards, this will also trigger
+            raise vol.Invalid("Multi-level wildcard must be the last "
+                              "character in the topic filter.")
+        if len(value) > 1 and value[index - 1] != '/':
+            raise vol.Invalid("Multi-level wildcard must be after a topic "
+                              "level separator.")
+
+    return value
+
+
+def publish_topic(value):
+    """Validate that we can publish using this MQTT topic."""
+    value = _valid_topic(value)
+    if '+' in value or '#' in value:
+        raise vol.Invalid("Wildcards can not be used in topic names")
+    return value
+
+
+def mqtt_payload(value):
+    if value is None:
+        return ''
+    return string(value)
+
+
+def mqtt_qos(value):
+    try:
+        value = int(value)
+    except (TypeError, ValueError):
+        raise vol.Invalid(u"MQTT Quality of Service must be integer, got {}".format(value))
+    return one_of(0, 1, 2)(value)
+
+
 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))
@@ -314,14 +470,38 @@ 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 percentage(value):
+    if isinstance(value, (str, unicode)) and value.endswith('%'):
+        value = float(value[:-1].rstrip()) / 100.0
+    return zero_to_one_float(value)
+
+
+def invalid(message):
+    def validator(value):
+        raise vol.Invalid(message)
+    return validator
 
 
 def valid(value):
     return value
 
 
+def one_of(*values):
+    options = u', '.join(u"'{}'".format(x) for x in values)
+
+    def validator(value):
+        if value not in values:
+            raise vol.Invalid(u"Unknown value '{}', must be one of {}".format(value, options))
+        return value
+    return validator
+
+
+def lambda_(value):
+    if isinstance(value, Lambda):
+        return value
+    return Lambda(string_strict(value))
+
+
 REGISTERED_IDS = set()
 
 
@@ -334,23 +514,19 @@ def register_variable_id(value):
 
 
 class GenerateID(vol.Optional):
-    def __init__(self, basename):
+    def __init__(self, basename, key=CONF_ID):
         self._basename = basename
-        super(GenerateID, self).__init__(CONF_ID, default=self.default_variable_id)
+        super(GenerateID, self).__init__(key, 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({
+PLATFORM_SCHEMA = vol.Schema({
     vol.Required(CONF_PLATFORM): valid,
 })
 

esphomeyaml/const.py

@@ -1,8 +1,8 @@
 """Constants used by esphomeyaml."""
 
 MAJOR_VERSION = 1
-MINOR_VERSION = 2
-PATCH_VERSION = '2'
+MINOR_VERSION = 6
+PATCH_VERSION = '0'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
 
@@ -17,6 +17,7 @@ CONF_NAME = 'name'
 CONF_PLATFORM = 'platform'
 CONF_BOARD = 'board'
 CONF_SIMPLIFY = 'simplify'
+CONF_USE_BUILD_FLAGS = 'use_build_flags'
 CONF_LIBRARY_URI = 'library_uri'
 CONF_LOGGER = 'logger'
 CONF_WIFI = 'wifi'
@@ -32,6 +33,14 @@ CONF_BROKER = 'broker'
 CONF_USERNAME = 'username'
 CONF_POWER_SUPPLY = 'power_supply'
 CONF_ID = 'id'
+CONF_MQTT_ID = 'mqtt_id'
+CONF_SENSOR_ID = 'sensor_id'
+CONF_TRIGGER_ID = 'trigger_id'
+CONF_ACTION_ID = 'action_id'
+CONF_CONDITION_ID = 'condition_id'
+CONF_MAKE_ID = 'make_id'
+CONF_AUTOMATION_ID = 'automation_id'
+CONF_DELAY = 'delay'
 CONF_PIN = 'pin'
 CONF_NUMBER = 'number'
 CONF_INVERTED = 'inverted'
@@ -68,6 +77,15 @@ CONF_TOPIC = 'topic'
 CONF_PAYLOAD_AVAILABLE = 'payload_available'
 CONF_PAYLOAD_NOT_AVAILABLE = 'payload_not_available'
 CONF_DEFAULT_TRANSITION_LENGTH = 'default_transition_length'
+CONF_TRANSITION_LENGTH = 'transition_length'
+CONF_FLASH_LENGTH = 'flash_length'
+CONF_BRIGHTNESS = 'brightness'
+CONF_EFFECT = 'effect'
+CONF_ABOVE = 'above'
+CONF_BELOW = 'below'
+CONF_ON = 'on'
+CONF_IF = 'if'
+CONF_THEN = 'then'
 CONF_BINARY = 'binary'
 CONF_WHITE = 'white'
 CONF_RGBW = 'rgbw'
@@ -107,6 +125,14 @@ CONF_WINDOW_SIZE = 'window_size'
 CONF_SEND_EVERY = 'send_every'
 CONF_ALPHA = 'alpha'
 CONF_LAMBDA = 'lambda'
+CONF_THROTTLE = 'throttle'
+CONF_DELTA = 'delta'
+CONF_OR = 'or'
+CONF_AND = 'and'
+CONF_RANGE = 'range'
+CONF_UNIQUE = 'unique'
+CONF_HEARTBEAT = 'heartbeat'
+CONF_DEBOUNCE = 'debounce'
 CONF_UPDATE_INTERVAL = 'update_interval'
 CONF_PULL_MODE = 'pull_mode'
 CONF_COUNT_MODE = 'count_mode'
@@ -133,11 +159,12 @@ CONF_SONY = 'sony'
 CONF_PANASONIC = 'panasonic'
 CONF_REPEAT = 'repeat'
 CONF_TIMES = 'times'
-CONF_WAIT_TIME_US = 'wait_time_us'
+CONF_WAIT_TIME = 'wait_time'
 CONF_OSCILLATION_OUTPUT = 'oscillation_output'
 CONF_SPEED = 'speed'
 CONF_OSCILLATION_STATE_TOPIC = 'oscillation_state_topic'
 CONF_OSCILLATION_COMMAND_TOPIC = 'oscillation_command_topic'
+CONF_OSCILLATING = 'oscillating'
 CONF_SPEED_STATE_TOPIC = 'speed_state_topic'
 CONF_SPEED_COMMAND_TOPIC = 'speed_command_topic'
 CONF_LOW = 'low'
@@ -151,6 +178,59 @@ CONF_RATE = 'rate'
 CONF_ADS1115_ID = 'ads1115_id'
 CONF_MULTIPLEXER = 'multiplexer'
 CONF_GAIN = 'gain'
+CONF_SLEEP_DURATION = 'sleep_duration'
+CONF_WAKEUP_PIN = 'wakeup_pin'
+CONF_RUN_CYCLES = 'run_cycles'
+CONF_RUN_DURATION = 'run_duration'
+CONF_AP = 'ap'
+CONF_CSS_URL = 'css_url'
+CONF_JS_URL = 'js_url'
+CONF_SSL_FINGERPRINTS = 'ssl_fingerprints'
+CONF_PCF8574 = 'pcf8574'
+CONF_PCF8575 = 'pcf8575'
+CONF_SCAN = 'scan'
+CONF_KEEPALIVE = 'keepalive'
+CONF_INTEGRATION_TIME = 'integration_time'
+CONF_RECEIVE_TIMEOUT = 'receive_timeout'
+CONF_SCAN_INTERVAL = 'scan_interval'
+CONF_MAC_ADDRESS = 'mac_address'
+CONF_SETUP_MODE = 'setup_mode'
+CONF_IIR_FILTER = 'iir_filter'
+CONF_MEASUREMENT_DURATION = 'measurement_duration'
+CONF_LOW_VOLTAGE_REFERENCE = 'low_voltage_reference'
+CONF_HIGH_VOLTAGE_REFERENCE = 'high_voltage_reference'
+CONF_VOLTAGE_ATTENUATION = 'voltage_attenuation'
+CONF_THRESHOLD = 'threshold'
+CONF_OVERSAMPLING = 'oversampling'
+CONF_GAS_RESISTANCE = 'gas_resistance'
+CONF_NUM_LEDS = 'num_leds'
+CONF_MAX_REFRESH_RATE = 'max_refresh_rate'
+CONF_CHIPSET = 'chipset'
+CONF_DATA_PIN = 'data_pin'
+CONF_CLOCK_PIN = 'clock_pin'
+CONF_RGB_ORDER = 'rgb_order'
+CONF_ACCURACY = 'accuracy'
+CONF_BOARD_FLASH_MODE = 'board_flash_mode'
+CONF_ON_PRESS = 'on_press'
+CONF_ON_RELEASE = 'on_release'
+CONF_ON_CLICK = 'on_click'
+CONF_ON_DOUBLE_CLICK = 'on_double_click'
+CONF_MIN_LENGTH = 'min_length'
+CONF_MAX_LENGTH = 'max_length'
+CONF_ON_VALUE = 'on_value'
+CONF_ON_RAW_VALUE = 'on_raw_value'
+CONF_ON_VALUE_RANGE = 'on_value_range'
+CONF_ON_MESSAGE = 'on_message'
+CONF_PIN_CS = 'pin_cs'
+CONF_PIN_CLOCK = 'pin_clock'
+CONF_PIN_MISO = 'pin_miso'
+CONF_TURN_ON_ACTION = 'turn_on_action'
+CONF_TURN_OFF_ACTION = 'turn_off_action'
+CONF_OPEN_ACTION = 'open_action'
+CONF_CLOSE_ACTION = 'close_action'
+CONF_STOP_ACTION = 'stop_action'
+CONF_DOMAIN = 'domain'
+CONF_OPTIMISTIC = 'optimistic'
 
 ESP32_BOARDS = [
     'featheresp32', 'node32s', 'espea32', 'firebeetle32', 'esp32doit-devkit-v1',

esphomeyaml/core.py

@@ -1,3 +1,7 @@
+import math
+from collections import OrderedDict
+
+
 class ESPHomeYAMLError(Exception):
     """General esphomeyaml exception occurred."""
     pass
@@ -16,3 +20,167 @@ class IPAddress(object):
 
     def __str__(self):
         return '.'.join(str(x) for x in self.args)
+
+
+class MACAddress(object):
+    def __init__(self, *parts):
+        if len(parts) != 6:
+            raise ValueError(u"MAC Address must consist of 6 items")
+        self.parts = parts
+
+    def __str__(self):
+        return ':'.join('{:02X}'.format(part) for part in self.parts)
+
+
+def is_approximately_integer(value):
+    if isinstance(value, (int, long)):
+        return True
+    return abs(value - round(value)) < 0.001
+
+
+class TimePeriod(object):
+    def __init__(self, microseconds=None, milliseconds=None, seconds=None,
+                 minutes=None, hours=None, days=None):
+        if days is not None:
+            if not is_approximately_integer(days):
+                frac_days, days = math.modf(days)
+                hours = (hours or 0) + frac_days * 24
+            self.days = int(round(days))
+        else:
+            self.days = None
+
+        if hours is not None:
+            if not is_approximately_integer(hours):
+                frac_hours, hours = math.modf(hours)
+                minutes = (minutes or 0) + frac_hours * 60
+            self.hours = int(round(hours))
+        else:
+            self.hours = None
+
+        if minutes is not None:
+            if not is_approximately_integer(minutes):
+                frac_minutes, minutes = math.modf(minutes)
+                seconds = (seconds or 0) + frac_minutes * 60
+            self.minutes = int(round(minutes))
+        else:
+            self.minutes = None
+
+        if seconds is not None:
+            if not is_approximately_integer(seconds):
+                frac_seconds, seconds = math.modf(seconds)
+                milliseconds = (milliseconds or 0) + frac_seconds * 1000
+            self.seconds = int(round(seconds))
+        else:
+            self.seconds = None
+
+        if milliseconds is not None:
+            if not is_approximately_integer(milliseconds):
+                frac_milliseconds, milliseconds = math.modf(milliseconds)
+                microseconds = (microseconds or 0) + frac_milliseconds * 1000
+            self.milliseconds = int(round(milliseconds))
+        else:
+            self.milliseconds = None
+
+        if microseconds is not None:
+            if not is_approximately_integer(microseconds):
+                raise ValueError("Maximum precision is microseconds")
+            self.microseconds = int(round(microseconds))
+        else:
+            self.microseconds = None
+
+    def as_dict(self):
+        out = OrderedDict()
+        if self.microseconds is not None:
+            out['microseconds'] = self.microseconds
+        if self.milliseconds is not None:
+            out['milliseconds'] = self.milliseconds
+        if self.seconds is not None:
+            out['seconds'] = self.seconds
+        if self.minutes is not None:
+            out['minutes'] = self.minutes
+        if self.hours is not None:
+            out['hours'] = self.hours
+        if self.days is not None:
+            out['days'] = self.days
+        return out
+
+    @property
+    def total_microseconds(self):
+        return self.total_milliseconds * 1000 + (self.microseconds or 0)
+
+    @property
+    def total_milliseconds(self):
+        return self.total_seconds * 1000 + (self.milliseconds or 0)
+
+    @property
+    def total_seconds(self):
+        return self.total_minutes * 60 + (self.seconds or 0)
+
+    @property
+    def total_minutes(self):
+        return self.total_hours * 60 + (self.minutes or 0)
+
+    @property
+    def total_hours(self):
+        return self.total_days * 24 + (self.hours or 0)
+
+    @property
+    def total_days(self):
+        return self.days or 0
+
+    def __eq__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds == other.total_microseconds
+
+    def __ne__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds != other.total_microseconds
+
+    def __lt__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds < other.total_microseconds
+
+    def __gt__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds > other.total_microseconds
+
+    def __le__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds <= other.total_microseconds
+
+    def __ge__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds >= other.total_microseconds
+
+
+class TimePeriodMicroseconds(TimePeriod):
+    pass
+
+
+class TimePeriodMilliseconds(TimePeriod):
+    pass
+
+
+class TimePeriodSeconds(TimePeriod):
+    pass
+
+
+class Lambda(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return u'Lambda<{}>'.format(self.value)
+
+
+CONFIG_PATH = None
+SIMPLIFY = True
+ESP_PLATFORM = ''
+BOARD = ''
+RAW_CONFIG = None

esphomeyaml/dashboard/dashboard.py

@@ -0,0 +1,177 @@
+from __future__ import print_function
+
+import codecs
+import json
+import logging
+import os
+import random
+import subprocess
+
+try:
+    import tornado
+    import tornado.gen
+    import tornado.ioloop
+    import tornado.iostream
+    import tornado.process
+    import tornado.web
+    import tornado.websocket
+    import tornado.concurrent
+except ImportError as err:
+    pass
+
+from esphomeyaml import const, core, __main__
+from esphomeyaml.__main__ import get_serial_ports, get_base_path, get_name
+from esphomeyaml.helpers import quote
+
+_LOGGER = logging.getLogger(__name__)
+CONFIG_DIR = ''
+
+# pylint: disable=abstract-method, arguments-differ
+class EsphomeyamlCommandWebSocket(tornado.websocket.WebSocketHandler):
+    def __init__(self, application, request, **kwargs):
+        super(EsphomeyamlCommandWebSocket, self).__init__(application, request, **kwargs)
+        self.proc = None
+        self.closed = False
+
+    def on_message(self, message):
+        if self.proc is not None:
+            return
+        command = self.build_command(message)
+        _LOGGER.debug(u"WebSocket opened for command %s", [quote(x) for x in command])
+        self.proc = tornado.process.Subprocess(command,
+                                               stdout=tornado.process.Subprocess.STREAM,
+                                               stderr=subprocess.STDOUT)
+        self.proc.set_exit_callback(self.proc_on_exit)
+        tornado.ioloop.IOLoop.current().spawn_callback(self.redirect_stream)
+
+    @tornado.gen.coroutine
+    def redirect_stream(self):
+        while True:
+            try:
+                data = yield self.proc.stdout.read_until_regex('[\n\r]')
+            except tornado.iostream.StreamClosedError:
+                break
+            if data.endswith('\r') and random.randrange(100) < 90:
+                continue
+            data = data.replace('\033', '\\033')
+            self.write_message({'event': 'line', 'data': data})
+
+    def proc_on_exit(self, returncode):
+        if not self.closed:
+            _LOGGER.debug("Process exited with return code %s", returncode)
+            self.write_message({'event': 'exit', 'code': returncode})
+
+    def on_close(self):
+        self.closed = True
+        if self.proc is not None and self.proc.returncode is None:
+            _LOGGER.debug("Terminating process")
+            self.proc.proc.terminate()
+
+    def build_command(self, message):
+        raise NotImplementedError
+
+
+class EsphomeyamlLogsHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = CONFIG_DIR + '/' + js['configuration']
+        return ["esphomeyaml", config_file, "logs", '--serial-port', js["port"], '--escape']
+
+
+class EsphomeyamlRunHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "run", '--upload-port', js["port"],
+                '--escape', '--use-esptoolpy']
+
+
+class EsphomeyamlCompileHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "compile"]
+
+
+class SerialPortRequestHandler(tornado.web.RequestHandler):
+    def get(self):
+        ports = get_serial_ports()
+        data = []
+        for port, desc in ports:
+            if port == '/dev/ttyAMA0':
+                # ignore RPi built-in serial port
+                continue
+            data.append({'port': port, 'desc': desc})
+        data.append({'port': 'OTA', 'desc': 'Over-The-Air Upload/Logs'})
+        self.write(json.dumps(data))
+
+
+class WizardRequestHandler(tornado.web.RequestHandler):
+    def post(self):
+        from esphomeyaml import wizard
+
+        kwargs = {k: ''.join(v) for k, v in self.request.arguments.iteritems()}
+        config = wizard.wizard_file(**kwargs)
+        destination = os.path.join(CONFIG_DIR, kwargs['name'] + '.yaml')
+        with codecs.open(destination, 'w') as f_handle:
+            f_handle.write(config)
+
+        self.redirect('/')
+
+
+class DownloadBinaryRequestHandler(tornado.web.RequestHandler):
+    def get(self):
+        configuration = self.get_argument('configuration')
+        config_file = os.path.join(CONFIG_DIR, configuration)
+        core.CONFIG_PATH = config_file
+        config = __main__.read_config(core.CONFIG_PATH)
+        name = get_name(config)
+        path = os.path.join(get_base_path(config), '.pioenvs', name, 'firmware.bin')
+        self.set_header('Content-Type', 'application/octet-stream')
+        self.set_header("Content-Disposition", 'attachment; filename="{}.bin"'.format(name))
+        with open(path, 'rb') as f:
+            while 1:
+                data = f.read(16384)  # or some other nice-sized chunk
+                if not data:
+                    break
+                self.write(data)
+        self.finish()
+
+
+class MainRequestHandler(tornado.web.RequestHandler):
+    def get(self):
+        files = sorted([f for f in os.listdir(CONFIG_DIR) if f.endswith('.yaml') and
+                        not f.startswith('.')])
+        full_path_files = [os.path.join(CONFIG_DIR, f) for f in files]
+        self.render("templates/index.html", files=files, full_path_files=full_path_files,
+                    version=const.__version__)
+
+
+def make_app():
+    static_path = os.path.join(os.path.dirname(__file__), 'static')
+    return tornado.web.Application([
+        (r"/", MainRequestHandler),
+        (r"/logs", EsphomeyamlLogsHandler),
+        (r"/run", EsphomeyamlRunHandler),
+        (r"/compile", EsphomeyamlCompileHandler),
+        (r"/download.bin", DownloadBinaryRequestHandler),
+        (r"/serial-ports", SerialPortRequestHandler),
+        (r"/wizard.html", WizardRequestHandler),
+        (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': static_path}),
+    ], debug=False)
+
+
+def start_web_server(args):
+    global CONFIG_DIR
+    CONFIG_DIR = args.configuration
+    if not os.path.exists(CONFIG_DIR):
+        os.makedirs(CONFIG_DIR)
+
+    _LOGGER.info("Starting dashboard web server on port %s and configuration dir %s...",
+                 args.port, CONFIG_DIR)
+    app = make_app()
+    app.listen(args.port)
+    try:
+        tornado.ioloop.IOLoop.current().start()
+    except KeyboardInterrupt:
+        _LOGGER.info("Shutting down...")

esphomeyaml/dashboard/templates/index.html

@@ -0,0 +1,738 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>esphomeyaml Dashboard</title>
+  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0-beta/css/materialize.min.css">
+
+  <link rel="stylesheet" href="/static/materialize-stepper.min.css">
+
+  <!-- jQuery :( -->
+  <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.2.4/jquery.min.js"></script>
+  <script src="https://code.jquery.com/ui/1.8.5/jquery-ui.min.js" integrity="sha256-fOse6WapxTrUSJOJICXXYwHRJOPa6C1OUQXi7C9Ddy8=" crossorigin="anonymous"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0-beta/js/materialize.min.js"></script>
+  <script src="https://ajax.aspnetcdn.com/ajax/jquery.validate/1.15.0/jquery.validate.min.js"></script>
+
+
+  <script src="/static/materialize-stepper.min.js"></script>
+
+  <style>
+    nav .brand-logo {
+      margin-left: 48px;
+      font-size: 20px;
+    }
+
+    main .container {
+      margin-top: -12vh;
+      flex-shrink: 0;
+    }
+
+    .ribbon {
+      width: 100%;
+      height: 17vh;
+      background-color: #3F51B5;
+      flex-shrink: 0;
+    }
+
+    .ribbon-fab:not(.tap-target-origin) {
+      position: absolute;
+      right: 24px;
+      top: calc(17vh + 34px);
+    }
+
+    i.very-large {
+      font-size: 8rem;
+      padding-top: 2px;
+      color: #424242;
+    }
+
+    .card .card-content {
+      padding-left: 18px;
+      padding-bottom: 10px;
+    }
+
+    .chip {
+      height: 26px;
+      font-size: 12px;
+      line-height: 26px;
+    }
+
+    .log {
+      background-color: #1c1c1c;
+      margin-top: 0;
+      margin-bottom: 0;
+      font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
+      font-size: 12px;
+      padding: 16px;
+      overflow: auto;
+      line-height: 1.45;
+      border-radius: 3px;
+      white-space: pre-wrap;
+      overflow-wrap: break-word;
+      color: #DDD;
+    }
+
+    .inlinecode {
+      box-sizing: border-box;
+      padding: 0.2em 0.4em;
+      margin: 0;
+      font-size: 85%;
+      background-color: rgba(27,31,35,0.05);
+      border-radius: 3px;
+      font-family: "SFMono-Regular",Consolas,"Liberation Mono",Menlo,Courier,monospace;
+    }
+
+    .log.bold {
+      font-weight: bold;
+    }
+
+    .log .v {
+      color: #888888;
+    }
+
+    .log .d {
+      color: #00DDDD;
+    }
+
+    .log .c {
+      color: magenta;
+    }
+
+    .log .i {
+      color: limegreen;
+    }
+
+    .log .w {
+      color: yellow;
+    }
+
+    .log .e {
+      color: red;
+      font-weight: bold;
+    }
+
+    .log .e {
+      color: red;
+    }
+
+    .log .ww {
+      color: white;
+    }
+
+    .modal {
+      width: 90%;
+      max-height: 85%;
+      height: 80% !important;
+    }
+
+    .page-footer {
+      padding-top: 0;
+    }
+
+    body {
+      display: flex;
+      min-height: 100vh;
+      flex-direction: column;
+    }
+
+    main {
+      flex: 1 0 auto;
+    }
+
+    ul.browser-default {
+      padding-left: 30px;
+      margin-top: 10px;
+      margin-bottom: 15px;
+    }
+
+    ul.browser-default li {
+      list-style-type: initial;
+    }
+
+    ul.stepper:not(.horizontal) .step.active::before, ul.stepper:not(.horizontal) .step.done::before, ul.stepper.horizontal .step.active .step-title::before, ul.stepper.horizontal .step.done .step-title::before {
+      background-color: #3f51b5 !important;
+    }
+
+    .select-port-container {
+      margin-top: 19px;
+    }
+  </style>
+</head>
+<body>
+
+<header>
+<nav>
+  <div class="nav-wrapper indigo">
+    <a href="#" class="brand-logo left">esphomeyaml Dashboard</a>
+  </div>
+</nav>
+
+<div class="ribbon"></div>
+</header>
+
+<main>
+<div class="container">
+  {% for file, full_path in zip(files, full_path_files) %}
+  <div class="row">
+    <div class="col s8 offset-s2 m10 offset-m1 l12">
+      <div class="card horizontal">
+        <div class="card-image center-align">
+          <i class="material-icons very-large icon-grey">memory</i>
+        </div>
+        <div class="card-stacked">
+          <div class="card-content">
+            <span class="card-title">{{ escape(file) }}</span>
+            <p>
+              Full path: <code class="inlinecode">{{ escape(full_path) }}</code>
+            </p>
+          </div>
+          <div class="card-action">
+            <a href="#" class="action-upload" data-node="{{ file }}">Upload</a>
+            <a href="#" class="action-compile" data-node="{{ file }}">Compile</a>
+            <a href="#" class="action-show-logs" data-node="{{ file }}">Show Logs</a>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+  {% end %}
+</div>
+
+<div id="modal-logs" class="modal modal-fixed-footer">
+  <div class="modal-content">
+    <h4>Show Logs</h4>
+    <div class="upload-port row">
+      <div class="col s12">
+        <h5>Found multiple serial ports, please choose one:</h5>
+      </div>
+      <div class="input-field col s8">
+        <select></select>
+      </div>
+      <div class="col s4 select-port-container">
+        <button class="btn waves-effect waves-light upload-port-submit" type="submit" name="action">Select
+          <i class="material-icons right">send</i>
+        </button>
+      </div>
+    </div>
+    <div class="log-container">
+      <pre class="log"></pre>
+    </div>
+  </div>
+  <div class="modal-footer">
+    <a class="modal-close waves-effect waves-green btn-flat">Close</a>
+  </div>
+</div>
+
+<div id="modal-upload" class="modal modal-fixed-footer">
+  <div class="modal-content">
+    <h4>Compile And Upload</h4>
+    <div class="upload-port row">
+      <div class="col s12">
+        <h5>Found multiple upload options, please choose one:</h5>
+      </div>
+      <div class="input-field col s8">
+        <select></select>
+      </div>
+      <div class="col s4 select-port-container">
+        <button class="btn waves-effect waves-light upload-port-submit" type="submit" name="action">Select
+          <i class="material-icons right">send</i>
+        </button>
+      </div>
+    </div>
+    <div class="log-container">
+      <pre class="log"></pre>
+    </div>
+  </div>
+  <div class="modal-footer">
+    <a class="modal-close waves-effect waves-green btn-flat">Stop</a>
+  </div>
+</div>
+
+<div id="modal-compile" class="modal modal-fixed-footer">
+  <div class="modal-content">
+    <h4>Compile</h4>
+    <div class="log-container">
+      <pre class="log"></pre>
+    </div>
+  </div>
+  <div class="modal-footer">
+    <a class="modal-close waves-effect waves-green btn-flat disabled download-binary">Download Binary</a>
+    <a class="modal-close waves-effect waves-green btn-flat">Stop</a>
+  </div>
+</div>
+
+<div id="modal-wizard" class="modal">
+  <div class="modal-content">
+    <form action="/wizard.html" method="POST">
+    <ul class="stepper linear">
+      <li class="step active">
+        <div class="step-title waves-effect">Introduction And Name</div>
+        <div class="step-content">
+          <div class="row">
+            <p>
+              Hi there! I'm the esphomeyaml setup wizard and will guide you through setting up
+              your first ESP8266 or ESP32-powered device using esphomeyaml.
+            </p>
+              <a href="https://www.espressif.com/en/products/hardware/esp8266ex/overview" target="_blank">ESP8266s</a> and
+              their successors (the <a href="https://www.espressif.com/en/products/hardware/esp32/overview" target="_blank">ESP32s</a>)
+              are great low-cost microcontrollers that can communicate with the outside world using WiFi.
+              They're found in many devices such as the popular Sonoff/iTead, but also exist as development boards
+              such as the <a href="http://nodemcu.com/index_en.html" target="_blank">NodeMCU</a>.
+            <p>
+            </p>
+              <a href="https://esphomelib.com/esphomeyaml/index.html" target="_blank">esphomeyaml</a>,
+              the tool you're using here, creates custom firmwares for these devices using YAML configuration
+              files (similar to the ones you might be used to with Home Assistant).
+            <p>
+            </p>
+              This wizard will create a basic YAML configuration file for your "node" (the microcontroller).
+              Later, you will be able to customize this file and add some of
+              <a href="https://github.com/OttoWinter/esphomelib" target="_blank">esphomelib's</a>
+              many integrations.
+            <p>
+            <p>
+              First, I need to know what this node should be called. Choose this name wisely, changing this
+              later makes Over-The-Air Update attempts difficult.
+              It may only contain the characters <code class="inlinecode">a-z</code>,
+              <code class="inlinecode">0-9</code> and <code class="inlinecode">_</code>
+            </p>
+            <div class="input-field col s12">
+              <input id="node_name" class="validate" type="text" name="name" required>
+              <label for="node_name">Name of node</label>
+            </div>
+          </div>
+          <div class="step-actions">
+            <button class="waves-effect waves-dark btn indigo next-step"">CONTINUE</button>
+          </div>
+        </div>
+      </li>
+      <li class="step">
+        <div class="step-title waves-effect">Device Type</div>
+        <div class="step-content">
+          <div class="row">
+            <p>
+              Great! Now I need to know what type of microcontroller you're using so that I can compile firmware for them.
+              Please choose either ESP32 or ESP8266 (use ESP8266 for Sonoff devices). Note that the ESP32 is currently
+              unsupported if HassIO is running on a Raspberry Pi.
+            </p>
+            <div class="input-field col s12">
+              <select id="esp_type" name="platform" required>
+                <option value="ESP8266">ESP8266</option>
+                <option value="ESP32">ESP32</option>
+              </select>
+              <label>Microcontroller Type</label>
+            </div>
+            <p>
+              I'm also going to need to know which type of board you're using. Please go to
+              <a href="http://docs.platformio.org/en/latest/platforms/espressif32.html#boards" target="_blank">ESP32 boards</a> or
+              <a href="http://docs.platformio.org/en/latest/platforms/espressif8266.html#boards" target="_blank">ESP8266 boards</a>,
+              find your board and enter it here. For example, enter <code class="inlinecode">nodemcuv2</code>
+              for ESP8266 NodeMCU boards. Note: Use <code class="inlinecode">esp01_1m</code> for Sonoff devices.
+            </p>
+            <div class="input-field col s12">
+              <input id="board_type" class="validate" type="text" name="board" required>
+              <label for="board_type">Board Type</label>
+            </div>
+          </div>
+          <div class="step-actions">
+            <button class="waves-effect waves-dark btn indigo next-step">CONTINUE</button>
+          </div>
+        </div>
+      </li>
+      <li class="step">
+        <div class="step-title waves-effect">WiFi And Over-The-Air Updates</div>
+        <div class="step-content">
+          <div class="row">
+            <p>
+              Thanks! Now I need to know what WiFi Access Point I should instruct the node to connect to.
+              Please enter an SSID (name of the WiFi network) and password (leave empty for no password).
+            </p>
+            <div class="input-field col s12">
+              <input id="wifi_ssid" class="validate" type="text" name="ssid" required>
+              <label for="wifi_ssid">WiFi SSID</label>
+            </div>
+            <div class="input-field col s12">
+              <input id="wifi_password" name="psk" type="password">
+              <label for="wifi_password">WiFi Password</label>
+            </div>
+            <p>
+              Esphomelib automatically sets up an Over-The-Air update server on the node
+              so that you only need to flash a firmware once. Optionally, you can set a password for this
+              upload process here.
+            </p>
+            <div class="input-field col s12">
+              <input id="ota_password" class="validate" name="ota_password" type="password">
+              <label for="ota_password">OTA Password</label>
+            </div>
+          </div>
+          <div class="step-actions">
+            <button class="waves-effect waves-dark btn indigo next-step">CONTINUE</button>
+          </div>
+        </div>
+      </li>
+      <li class="step">
+        <div class="step-title waves-effect">MQTT</div>
+        <div class="step-content">
+          <div class="row">
+            <p>
+              esphomelib connects to your Home Assistant instance via
+              <a href="https://www.home-assistant.io/docs/mqtt/">MQTT</a>. If you haven't already, please set up
+              MQTT on your Home Assistant server, for example with the awesome
+              <a href="https://www.home-assistant.io/addons/mosquitto/">Mosquitto Hass.io Add-on</a>.
+            </p>
+            <p>
+              When you're done with that, please enter your MQTT broker here. For example
+              <code class="inlinecode">192.168.1.100</code> (Note
+              <code class="inlinecode">hassio.local</code> often doesn't work, please use a static IP).
+              Please also specify the MQTT username and password you wish esphomelib to use
+              (leave them empty if you're not using any authentication).
+            </p>
+            <div class="input-field col s12">
+              <input id="mqtt_broker" class="validate" type="text" name="broker" required>
+              <label for="mqtt_broker">MQTT Broker</label>
+            </div>
+            <div class="input-field col s6">
+              <input id="mqtt_username" class="validate" type="text" name="mqtt_username">
+              <label for="mqtt_username">MQTT Username</label>
+            </div>
+            <div class="input-field col s6">
+              <input id="mqtt_password" class="validate" name="mqtt_password" type="password">
+              <label for="mqtt_password">MQTT Password</label>
+            </div>
+          </div>
+          <div class="step-actions">
+            <button class="waves-effect waves-dark btn indigo next-step">CONTINUE</button>
+          </div>
+        </div>
+      </li>
+      <li class="step">
+        <div class="step-title waves-effect">Done!</div>
+        <div class="step-content">
+          <p>
+            Hooray! 🎉🎉🎉 You've successfully created your first esphomeyaml configuration file.
+            When you click Submit, I will save this configuration file under
+            <code class="inlinecode">&lt;HASS_CONFIG_FOLDER&gt;/esphomeyaml/&lt;NAME_OF_NODE&gt;.yaml</code> and
+            you will be able to edit this file with the
+            <a href="https://www.home-assistant.io/addons/configurator/" target="_blank">HASS Configuratior add-on</a>.
+          </p>
+          <h5>Next steps</h5>
+          <ul class="browser-default">
+            <li>
+              Flash the firmware. This can be done using the “UPLOAD” option in the dashboard. See
+              <a href="https://esphomelib.com/esphomeyaml/index.html#using-with" target="_blank">this</a>
+              for guides on how to flash different types of devices. Note that you need to restart this add-on
+              for newly plugged in serial devices to be detected.
+            </li>
+            <li>
+              See the <a href="https://esphomelib.com/esphomeyaml/index.html" target="_blank">esphomeyaml index</a>
+              for a list of supported sensors/devices.
+            </li>
+            <li>
+              Join the <a href="https://discord.gg/KhAMKrd" target="_blank">Discord server</a> and say hi. When I
+              have time, I would be happy to help with issues and discuss new features.
+            </li>
+            <li>
+              Star <a href="https://github.com/OttoWinter/esphomelib" target="_blank">esphomelib</a> and
+              <a href="https://github.com/OttoWinter/esphomeyaml" target="_blank">esphomeyaml</a> on GitHub and
+              report issues using the bug trackers there.
+            </li>
+          </ul>
+          <div class="step-actions">
+            <button class="waves-effect waves-dark btn indigo" type="submit">SUBMIT</button>
+          </div>
+        </div>
+      </li>
+    </ul>
+    </form>
+  </div>
+  <div class="modal-footer">
+    <a href="#!" class="modal-close waves-effect waves-green btn-flat">Abort</a>
+  </div>
+</div>
+
+<a class="btn-floating btn-large ribbon-fab waves-effect waves-light pink accent-2" id="setup-wizard-start">
+  <i class="material-icons">add</i>
+</a>
+
+<div class="tap-target pink lighten-1" data-target="setup-wizard-start">
+  <div class="tap-target-content">
+    <h5>Set up your first Node</h5>
+    <p>
+      Huh... It seems like you you don't have any esphomeyaml configuration files yet...
+      Fortunately, there's a setup wizard that will step you through setting up your first node 🎉
+    </p>
+  </div>
+</div>
+</main>
+
+<footer class="page-footer indigo darken-1">
+  <div class="container">
+
+  </div>
+  <div class="footer-copyright">
+    <div class="container">
+      © 2018 Copyright Otto Winter, Made with <a class="grey-text text-lighten-4" href="https://materializecss.com/" target="_blank">Materialize</a>
+      <a class="grey-text text-lighten-4 right" href="https://esphomelib.com/esphomeyaml/index.html" target="_blank">esphomeyaml {{ version }} Documentation</a>
+    </div>
+  </div>
+</footer>
+
+<script>
+  document.addEventListener('DOMContentLoaded', () => {
+    M.AutoInit(document.body);
+  });
+
+  const colorReplace = (input) => {
+    input = input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+    input = input.replace(/\\033\[(?:0;)?31m/g, '<span class="e">');
+    input = input.replace(/\\033\[(?:1;)?31m/g, '<span class="e bold">');
+    input = input.replace(/\\033\[(?:0;)?32m/g, '<span class="i">');
+    input = input.replace(/\\033\[(?:1;)?32m/g, '<span class="i bold">');
+    input = input.replace(/\\033\[(?:0;)?33m/g, '<span class="w">');
+    input = input.replace(/\\033\[(?:1;)?33m/g, '<span class="w bold">');
+    input = input.replace(/\\033\[(?:0;)?35m/g, '<span class="c">');
+    input = input.replace(/\\033\[(?:1;)?35m/g, '<span class="c bold">');
+    input = input.replace(/\\033\[(?:0;)?36m/g, '<span class="d">');
+    input = input.replace(/\\033\[(?:1;)?36m/g, '<span class="d bold">');
+    input = input.replace(/\\033\[(?:0;)?37m/g, '<span class="v">');
+    input = input.replace(/\\033\[(?:1;)?37m/g, '<span class="v bold">');
+    input = input.replace(/\\033\[(?:0;)?38m/g, '<span class="vv">');
+    input = input.replace(/\\033\[(?:1;)?38m/g, '<span class="vv bold">');
+    input = input.replace(/\\033\[0m/g, '</span>');
+
+    return input;
+  };
+
+  let configuration = "";
+  const ws_url = 'ws://' + window.location.hostname + ':' + window.location.port;
+
+  const logsModalElem = document.getElementById("modal-logs");
+  const logsPortSelect = logsModalElem.querySelector('select');
+  const logsPortDiv = logsModalElem.querySelector(".upload-port");
+  const logsPortSubmit = logsModalElem.querySelector('.upload-port-submit');
+  let logsStart = undefined;
+
+  logsPortSubmit.addEventListener('click', () => {
+    const inst = M.FormSelect.getInstance(logsPortSelect);
+    logsStart(inst.getSelectedValues()[0]);
+    inst.destroy();
+  });
+
+  document.querySelectorAll(".action-show-logs").forEach((showLogs) => {
+    showLogs.addEventListener('click', (e) => {
+      configuration = e.target.getAttribute('data-node');
+      const modalInstance = M.Modal.getInstance(logsModalElem);
+      const log = logsModalElem.querySelector(".log");
+      log.innerHTML = "";
+
+      if (M.FormSelect.getInstance(logsPortSelect) !== undefined) {
+        M.FormSelect.getInstance(logsPortSelect).destroy();
+      }
+      modalInstance.open();
+
+      if (logsPortDiv.classList.contains('hide')) {
+        logsPortDiv.classList.remove('hide');
+      }
+
+      logsStart = (port) => {
+        logsPortDiv.classList.add('hide');
+        const logSocket = new WebSocket(ws_url + "/logs");
+        logSocket.addEventListener('message', (event) => {
+          const data = JSON.parse(event.data);
+          if (data.event === "line") {
+            const msg = data.data;
+            log.innerHTML += colorReplace(msg);
+          } else if (data.event === "exit") {
+            if (data.code === 0) {
+              M.toast({html: "Program exited successfully!"});
+            } else {
+              M.toast({html: `Program failed with code ${data.code}`});
+            }
+          }
+        });
+        logSocket.addEventListener('open', () => {
+          const msg = JSON.stringify({configuration: configuration, port: port});
+          logSocket.send(msg);
+        });
+        logSocket.addEventListener('close', () => {
+          M.toast({html: 'Terminated process.'});
+        });
+        modalInstance.options.onCloseStart = () => {
+          logSocket.close();
+        };
+      };
+
+      fetch('/serial-ports').then(res => res.json())
+        .then(response => {
+          if (response.length > 1) {
+            logsPortSelect.innerHTML = "";
+            for (let i = 0; i < response.length; i++) {
+              const val = response[i];
+              logsPortSelect.innerHTML += `<option value="${val.port}">${val.port} (${val.desc})</option>`;
+            }
+            M.FormSelect.init(logsPortSelect, {});
+          } else {
+            logsStart("OTA");
+          }
+        });
+    });
+  });
+
+  const uploadModalElem = document.getElementById("modal-upload");
+  const uploadPortSelect = uploadModalElem.querySelector('select');
+  const uploadPortDiv = uploadModalElem.querySelector(".upload-port");
+  const uploadPortSubmit = uploadModalElem.querySelector('.upload-port-submit');
+  let uploadStart = undefined;
+
+  uploadPortSubmit.addEventListener('click', () => {
+    const inst = M.FormSelect.getInstance(uploadPortSelect);
+    uploadStart(inst.getSelectedValues()[0]);
+    inst.destroy();
+  });
+
+  document.querySelectorAll(".action-upload").forEach((showLogs) => {
+    showLogs.addEventListener('click', (e) => {
+      configuration = e.target.getAttribute('data-node');
+      const modalInstance = M.Modal.getInstance(uploadModalElem);
+      const log = uploadModalElem.querySelector(".log");
+      log.innerHTML = "";
+
+      if (M.FormSelect.getInstance(uploadPortSelect) !== undefined) {
+        M.FormSelect.getInstance(uploadPortSelect).destroy();
+      }
+      modalInstance.open();
+
+      if (uploadPortDiv.classList.contains('hide')) {
+        uploadPortDiv.classList.remove('hide');
+      }
+
+      uploadStart = (port) => {
+        uploadPortDiv.classList.add('hide');
+        const logSocket = new WebSocket(ws_url + "/run");
+        logSocket.addEventListener('message', (event) => {
+          const data = JSON.parse(event.data);
+          if (data.event === "line") {
+            const msg = data.data;
+            log.innerHTML += colorReplace(msg);
+          } else if (data.event === "exit") {
+            if (data.code === 0) {
+              M.toast({html: "Program exited successfully!"});
+            } else {
+              M.toast({html: `Program failed with code ${data.code}`});
+            }
+          }
+        });
+        logSocket.addEventListener('open', () => {
+          const msg = JSON.stringify({configuration: configuration, port: port});
+          logSocket.send(msg);
+        });
+        logSocket.addEventListener('close', () => {
+          M.toast({html: 'Terminated process.'});
+        });
+        modalInstance.options.onCloseStart = () => {
+          logSocket.close();
+        };
+      };
+
+      fetch('/serial-ports').then(res => res.json())
+        .then(response => {
+          if (response.length > 1) {
+            uploadPortSelect.innerHTML = "";
+            for (let i = 0; i < response.length; i++) {
+              const val = response[i];
+              uploadPortSelect.innerHTML += `<option value="${val.port}">${val.port} (${val.desc})</option>`;
+            }
+            M.FormSelect.init(uploadPortSelect, {});
+          } else {
+            uploadStart("OTA");
+          }
+        });
+    });
+  });
+
+  const compileModalElem = document.getElementById("modal-compile");
+  const downloadButton = compileModalElem.querySelector('.download-binary');
+
+  document.querySelectorAll(".action-compile").forEach((showLogs) => {
+    showLogs.addEventListener('click', (e) => {
+      configuration = e.target.getAttribute('data-node');
+      const modalInstance = M.Modal.getInstance(compileModalElem);
+      const log = compileModalElem.querySelector(".log");
+      log.innerHTML = "";
+      downloadButton.classList.add('disabled');
+      modalInstance.open();
+
+      const logSocket = new WebSocket(ws_url + "/compile");
+      logSocket.addEventListener('message', (event) => {
+        const data = JSON.parse(event.data);
+        if (data.event === "line") {
+          const msg = data.data;
+          log.innerHTML += colorReplace(msg);
+        } else if (data.event === "exit") {
+          if (data.code === 0) {
+            M.toast({html: "Program exited successfully!"});
+            downloadButton.classList.remove('disabled');
+          } else {
+            M.toast({html: `Program failed with code ${data.code}`});
+          }
+        }
+      });
+      logSocket.addEventListener('open', () => {
+        const msg = JSON.stringify({configuration: configuration});
+        logSocket.send(msg);
+      });
+      logSocket.addEventListener('close', () => {
+        M.toast({html: 'Terminated process.'});
+      });
+      modalInstance.options.onCloseStart = () => {
+        logSocket.close();
+      };
+    });
+  });
+
+  downloadButton.addEventListener('click', () => {
+    const link = document.createElement("a");
+    link.download = name;
+    link.href = '/download.bin?configuration=' + encodeURIComponent(configuration);
+    link.click();
+  });
+
+  const modalSetupElem = document.getElementById("modal-wizard");
+  const setupWizardStart = document.getElementById('setup-wizard-start');
+  const startWizard = () => {
+    const modalInstance = M.Modal.getInstance(modalSetupElem);
+    modalInstance.open();
+
+    modalInstance.options.onCloseStart = () => {
+
+    };
+
+    $('.stepper').activateStepper({
+      linearStepsNavigation: false,
+      autoFocusInput: true,
+      autoFormCreation: true,
+      showFeedbackLoader: true,
+      parallel: false
+    });
+  };
+  setupWizardStart.addEventListener('click', startWizard);
+</script>
+
+{% if len(files) == 0 %}
+<script>
+  document.addEventListener('DOMContentLoaded', () => {
+    const tapTargetElem = document.querySelector('.tap-target');
+    const tapTargetInstance = M.TapTarget.getInstance(tapTargetElem);
+    tapTargetInstance.options.onOpen = () => {
+      $('.tap-target-origin').on('click', () => {
+        startWizard();
+      });
+    };
+    tapTargetInstance.open();
+  });
+</script>
+{% end %}
+
+</body>
+</html>

esphomeyaml/helpers.py

@@ -4,16 +4,16 @@ import logging
 import re
 from collections import OrderedDict, deque
 
+from esphomeyaml import core
 from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, \
     CONF_INVERTED, \
-    CONF_MODE, CONF_NUMBER, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_RETAIN, \
-    CONF_STATE_TOPIC, CONF_TOPIC
-from esphomeyaml.core import ESPHomeYAMLError, HexInt
+    CONF_MODE, CONF_NUMBER, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PCF8574, \
+    CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC
+from esphomeyaml.core import ESPHomeYAMLError, HexInt, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds, Lambda
 
 _LOGGER = logging.getLogger(__name__)
 
-SIMPLIFY = False
-
 
 def ensure_unique_string(preferred_string, current_strings):
     test_string = preferred_string
@@ -45,11 +45,22 @@ def indent(text, padding=u'  '):
 
 class Expression(object):
     def __init__(self):
-        pass
+        self.requires = []
+        self.required = False
 
     def __str__(self):
         raise NotImplementedError
 
+    def require(self):
+        self.required = True
+        for require in self.requires:
+            if require.required:
+                continue
+            require.require()
+
+    def has_side_effects(self):
+        return self.required
+
 
 class RawExpression(Expression):
     def __init__(self, text):
@@ -57,18 +68,28 @@ class RawExpression(Expression):
         self.text = text
 
     def __str__(self):
-        return self.text
+        return str(self.text)
 
 
+# pylint: disable=redefined-builtin
 class AssignmentExpression(Expression):
-    def __init__(self, lhs, rhs, obj):
+    def __init__(self, type, modifier, name, rhs, obj):
         super(AssignmentExpression, self).__init__()
-        self.obj = obj
-        self.lhs = safe_exp(lhs)
+        self.type = type
+        self.modifier = modifier
+        self.name = name
         self.rhs = safe_exp(rhs)
+        self.requires.append(self.rhs)
+        self.obj = obj
 
     def __str__(self):
-        return u"{} = {}".format(self.lhs, self.rhs)
+        type_ = self.type
+        if core.SIMPLIFY:
+            type_ = u'auto'
+        return u"{} {}{} = {}".format(type_, self.modifier, self.name, self.rhs)
+
+    def has_side_effects(self):
+        return self.rhs.has_side_effects()
 
 
 class ExpressionList(Expression):
@@ -78,20 +99,43 @@ class ExpressionList(Expression):
         args = list(args)
         while args and args[-1] is None:
             args.pop()
-        self.args = [safe_exp(x) for x in args]
+        self.args = []
+        for arg in args:
+            exp = safe_exp(arg)
+            self.requires.append(exp)
+            self.args.append(exp)
 
     def __str__(self):
-        text = u", ".join(unicode(x) for x in self.args)
+        text = u", ".join(str(x) for x in self.args)
         return indent_all_but_first_and_last(text)
 
 
+class TemplateArguments(Expression):
+    def __init__(self, *args):
+        super(TemplateArguments, self).__init__()
+        self.args = ExpressionList(*args)
+        self.requires.append(self.args)
+
+    def __str__(self):
+        return u'<{}>'.format(self.args)
+
+
 class CallExpression(Expression):
     def __init__(self, base, *args):
         super(CallExpression, self).__init__()
         self.base = base
+        if args and isinstance(args[0], TemplateArguments):
+            self.template_args = args[0]
+            self.requires.append(self.template_args)
+            args = args[1:]
+        else:
+            self.template_args = None
         self.args = ExpressionList(*args)
+        self.requires.append(self.args)
 
     def __str__(self):
+        if self.template_args is not None:
+            return u'{}{}({})'.format(self.base, self.template_args, self.args)
         return u'{}({})'.format(self.base, self.args)
 
 
@@ -99,12 +143,17 @@ class StructInitializer(Expression):
     def __init__(self, base, *args):
         super(StructInitializer, self).__init__()
         self.base = base
+        if isinstance(base, Expression):
+            self.requires.append(base)
         if not isinstance(args, OrderedDict):
             args = OrderedDict(args)
         self.args = OrderedDict()
         for key, value in args.iteritems():
-            if value is not None:
-                self.args[key] = safe_exp(value)
+            if value is None:
+                continue
+            exp = safe_exp(value)
+            self.args[key] = exp
+            self.requires.append(exp)
 
     def __str__(self):
         cpp = u'{}{{\n'.format(self.base)
@@ -115,32 +164,106 @@ class StructInitializer(Expression):
 
 
 class ArrayInitializer(Expression):
-    def __init__(self, *args):
+    def __init__(self, *args, **kwargs):
         super(ArrayInitializer, self).__init__()
-        self.args = [safe_exp(x) for x in args if x is not None]
+        self.multiline = kwargs.get('multiline', True)
+        self.args = []
+        for arg in args:
+            if arg is None:
+                continue
+            exp = safe_exp(arg)
+            self.args.append(exp)
+            self.requires.append(exp)
 
     def __str__(self):
         if not self.args:
             return u'{}'
-        cpp = u'{\n'
-        for arg in self.args:
-            cpp += u'  {},\n'.format(arg)
-        cpp += u'}'
+        if self.multiline:
+            cpp = u'{\n'
+            for arg in self.args:
+                cpp += u'  {},\n'.format(arg)
+            cpp += u'}'
+        else:
+            cpp = u'{' + u', '.join(str(arg) for arg in self.args) + u'}'
         return cpp
 
 
+# pylint: disable=invalid-name
+class ParameterExpression(Expression):
+    def __init__(self, type, id):
+        super(ParameterExpression, self).__init__()
+        self.type = type
+        self.id = id
+
+    def __str__(self):
+        return u"{} {}".format(self.type, self.id)
+
+
+class ParameterListExpression(Expression):
+    def __init__(self, *parameters):
+        super(ParameterListExpression, self).__init__()
+        self.parameters = []
+        for parameter in parameters:
+            if not isinstance(parameter, ParameterExpression):
+                parameter = ParameterExpression(*parameter)
+            self.parameters.append(parameter)
+            self.requires.append(parameter)
+
+    def __str__(self):
+        return u", ".join(unicode(x) for x in self.parameters)
+
+
+class LambdaExpression(Expression):
+    def __init__(self, parts, parameters, capture='=', return_type=None):
+        super(LambdaExpression, self).__init__()
+        self.parts = parts
+        if not isinstance(parameters, ParameterListExpression):
+            parameters = ParameterListExpression(*parameters)
+        self.parameters = parameters
+        self.requires.append(self.parameters)
+        self.capture = capture
+        self.return_type = return_type
+        if return_type is not None:
+            self.requires.append(return_type)
+        for i in range(1, len(parts), 2):
+            self.requires.append(parts[i])
+
+    def __str__(self):
+        cpp = u'[{}]({})'.format(self.capture, self.parameters)
+        if self.return_type is not None:
+            cpp += u' -> {}'.format(self.return_type)
+        cpp += u' {\n'
+        for part in self.parts:
+            cpp += unicode(part)
+        cpp += u'\n}'
+        return indent_all_but_first_and_last(cpp)
+
+
 class Literal(Expression):
     def __str__(self):
         raise NotImplementedError
 
 
+# From https://stackoverflow.com/a/14945195/8924614
+def cpp_string_escape(string, encoding='utf-8'):
+    if isinstance(string, unicode):
+        string = string.encode(encoding)
+    result = ''
+    for character in string:
+        if not (32 <= ord(character) < 127) or character in ('\\', '"'):
+            result += '\\%03o' % ord(character)
+        else:
+            result += character
+    return '"' + result + '"'
+
+
 class StringLiteral(Literal):
     def __init__(self, string):
         super(StringLiteral, self).__init__()
         self.string = string
 
     def __str__(self):
-        return u'"{}"'.format(self.string)
+        return u'{}'.format(cpp_string_escape(self.string))
 
 
 class IntLiteral(Literal):
@@ -171,9 +294,9 @@ class HexIntLiteral(Literal):
 
 
 class FloatLiteral(Literal):
-    def __init__(self, float_):
+    def __init__(self, value):
         super(FloatLiteral, self).__init__()
-        self.float_ = float_
+        self.float_ = value
 
     def __str__(self):
         return u"{:f}f".format(self.float_)
@@ -186,10 +309,18 @@ def safe_exp(obj):
         return BoolLiteral(obj)
     elif isinstance(obj, (str, unicode)):
         return StringLiteral(obj)
+    elif isinstance(obj, HexInt):
+        return HexIntLiteral(obj)
     elif isinstance(obj, (int, long)):
         return IntLiteral(obj)
     elif isinstance(obj, float):
         return FloatLiteral(obj)
+    elif isinstance(obj, TimePeriodMicroseconds):
+        return IntLiteral(int(obj.total_microseconds))
+    elif isinstance(obj, TimePeriodMilliseconds):
+        return IntLiteral(int(obj.total_milliseconds))
+    elif isinstance(obj, TimePeriodSeconds):
+        return IntLiteral(int(obj.total_seconds))
     raise ValueError(u"Object is not an expression", obj)
 
 
@@ -225,22 +356,31 @@ def statement(expression):
     return ExpressionStatement(expression)
 
 
+def register_variable(type, id, obj):
+    _VARIABLES[id] = obj, type
+
+
 # pylint: disable=redefined-builtin, invalid-name
 def variable(type, id, rhs):
-    lhs = RawExpression(u'{} {}'.format(type if not SIMPLIFY else u'auto', id))
     rhs = safe_exp(rhs)
     obj = MockObj(id, u'.')
-    add(AssignmentExpression(lhs, rhs, obj))
-    _VARIABLES[id] = obj, type
+    assignment = AssignmentExpression(type, '', id, rhs, obj)
+    add(assignment)
+    register_variable(type, id, obj)
+    obj.requires.append(assignment)
     return obj
 
 
-def Pvariable(type, id, rhs):
-    lhs = RawExpression(u'{} *{}'.format(type if not SIMPLIFY else u'auto', id))
+def Pvariable(type, id, rhs, has_side_effects=True):
     rhs = safe_exp(rhs)
-    obj = MockObj(id, u'->')
-    add(AssignmentExpression(lhs, rhs, obj))
-    _VARIABLES[id] = obj, type
+    if not has_side_effects and hasattr(rhs, '_has_side_effects'):
+        # pylint: disable=attribute-defined-outside-init, protected-access
+        rhs._has_side_effects = False
+    obj = MockObj(id, u'->', has_side_effects=has_side_effects)
+    assignment = AssignmentExpression(type, '*', id, rhs, obj)
+    add(assignment)
+    register_variable(type, id, obj)
+    obj.requires.append(assignment)
     return obj
 
 
@@ -250,74 +390,134 @@ _EXPRESSIONS = []
 
 
 def get_variable(id, type=None):
-    result = None
-    while _QUEUE:
+    def get_result():
         if id is not None:
             if id in _VARIABLES:
-                result = _VARIABLES[id][0]
-                break
+                return _VARIABLES[id][0]
         elif type is not None:
-            result = next((x[0] for x in _VARIABLES.itervalues() if x[1] == type), None)
-            if result is not None:
-                break
+            return next((x[0] for x in _VARIABLES.itervalues() if x[1] == type), None)
+        return None
+
+    while _QUEUE:
+        result = get_result()
+        if result is not None:
+            return result
         func, config = _QUEUE.popleft()
         func(config)
     if id is None and type is None:
         return None
+    result = get_result()
     if result is None:
-        if id is not None:
-            result = _VARIABLES[id][0]
-        elif type is not None:
-            result = next((x[0] for x in _VARIABLES.itervalues() if x[1] == type), None)
-
-        if result is None:
-            raise ESPHomeYAMLError(u"Couldn't find ID '{}' with type {}".format(id, type))
-    result.usages += 1
+        if type is None:
+            raise ESPHomeYAMLError(u"Couldn't find ID '{}'".format(id))
+        raise ESPHomeYAMLError(u"Couldn't find ID '{}' with type '{}'".format(id, type))
     return result
 
 
+def process_lambda(value, parameters, capture='=', return_type=None):
+    if value is None:
+        return None
+    parts = re.split(r'id\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)\.', value.value)
+    for i in range(1, len(parts), 2):
+        parts[i] = get_variable(parts[i])._
+    return LambdaExpression(parts, parameters, capture, return_type)
+
+
+def templatable(value, input_type, output_type):
+    if isinstance(value, Lambda):
+        return process_lambda(value, [(input_type, 'x')], return_type=output_type)
+    return value
+
+
 def add_task(func, config):
     _QUEUE.append((func, config))
 
 
-def add(expression):
+def add(expression, require=True):
+    if require and isinstance(expression, Expression):
+        expression.require()
     _EXPRESSIONS.append(expression)
     return expression
 
 
 class MockObj(Expression):
-    def __init__(self, base, op=u'.', parent=None):
+    def __init__(self, base, op=u'.', has_side_effects=True):
         self.base = base
         self.op = op
-        self.usages = 0
-        self.parent = parent
+        self._has_side_effects = has_side_effects
         super(MockObj, self).__init__()
 
     def __getattr__(self, attr):
+        if attr == u'_':
+            obj = MockObj(u'{}{}'.format(self.base, self.op))
+            obj.requires.append(self)
+            return obj
+        if attr == u'new':
+            obj = MockObj(u'new {}'.format(self.base), u'->')
+            obj.requires.append(self)
+            return obj
         next_op = u'.'
-        if attr.startswith(u'P'):
+        if attr.startswith(u'P') and self.op != '::':
             attr = attr[1:]
             next_op = u'->'
-        op = self.op
-        return MockObj(u'{}{}{}'.format(self.base, op, attr), next_op, self)
+        if attr.startswith(u'_'):
+            attr = attr[1:]
+        obj = MockObj(u'{}{}{}'.format(self.base, self.op, attr), next_op)
+        obj.requires.append(self)
+        return obj
 
     def __call__(self, *args, **kwargs):
-        self.usages += 1
-        it = self.parent
-        while it is not None:
-            it.usages += 1
-            it = it.parent
-        return CallExpression(self.base, *args)
+        call = CallExpression(self.base, *args)
+        obj = MockObj(call, self.op)
+        obj.requires.append(self)
+        obj.requires.append(call)
+        return obj
 
     def __str__(self):
-        return self.base
+        return unicode(self.base)
+
+    def require(self):
+        self.required = True
+        for require in self.requires:
+            if require.required:
+                continue
+            require.require()
+
+    def template(self, args):
+        if not isinstance(args, TemplateArguments):
+            args = TemplateArguments(args)
+        obj = MockObj(u'{}{}'.format(self.base, args))
+        obj.requires.append(self)
+        obj.requires.append(args)
+        return obj
+
+    def namespace(self, name):
+        obj = MockObj(u'{}{}{}'.format(self.base, self.op, name), u'::')
+        obj.requires.append(self)
+        return obj
+
+    def has_side_effects(self):
+        return self._has_side_effects
 
 
-App = MockObj(u'App')
+global_ns = MockObj('', '')
+float_ = global_ns.namespace('float')
+bool_ = global_ns.namespace('bool')
+std_ns = global_ns.namespace('std')
+std_string = std_ns.string
+uint8 = global_ns.namespace('uint8_t')
+uint16 = global_ns.namespace('uint16_t')
+uint32 = global_ns.namespace('uint32_t')
+NAN = global_ns.namespace('NAN')
+esphomelib_ns = global_ns  # using namespace esphomelib;
+NoArg = esphomelib_ns.NoArg
+App = esphomelib_ns.App
+Application = esphomelib_ns.namespace('Application')
+optional = esphomelib_ns.optional
 
-GPIOPin = MockObj(u'GPIOPin')
-GPIOOutputPin = MockObj(u'GPIOOutputPin')
-GPIOInputPin = MockObj(u'GPIOInputPin')
+GPIOPin = esphomelib_ns.GPIOPin
+GPIOOutputPin = esphomelib_ns.GPIOOutputPin
+GPIOInputPin = esphomelib_ns.GPIOInputPin
 
 
 def get_gpio_pin_number(conf):
@@ -326,25 +526,34 @@ def get_gpio_pin_number(conf):
     return conf[CONF_NUMBER]
 
 
-def exp_gpio_pin_(obj, conf, default_mode):
-    if isinstance(conf, int):
-        return conf
-    if conf.get(CONF_INVERTED) is None:
-        return obj(conf[CONF_NUMBER], conf.get(CONF_MODE))
-    return obj(conf[CONF_NUMBER], RawExpression(conf.get(CONF_MODE, default_mode)),
-               conf[CONF_INVERTED])
+def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
+    if conf is None:
+        return None
+    number = conf[CONF_NUMBER]
+    inverted = conf.get(CONF_INVERTED)
+    if CONF_PCF8574 in conf:
+        hub = get_variable(conf[CONF_PCF8574], 'io::PCF8574Component')
+        if default_mode == u'INPUT':
+            mode = conf.get(CONF_MODE, u'INPUT')
+            return hub.make_input_pin(number,
+                                      RawExpression('PCF8574_' + mode),
+                                      inverted)
+        elif default_mode == u'OUTPUT':
+            return hub.make_output_pin(number, inverted)
+        else:
+            raise ESPHomeYAMLError(u"Unknown default mode {}".format(default_mode))
+    if len(conf) == 1:
+        return IntLiteral(number)
+    mode = RawExpression(conf.get(CONF_MODE, default_mode))
+    return mock_obj(number, mode, inverted)
 
 
-def exp_gpio_pin(conf):
-    return GPIOPin(conf[CONF_NUMBER], conf[CONF_MODE], conf.get(CONF_INVERTED))
+def gpio_output_pin_expression(conf):
+    return generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT')
 
 
-def exp_gpio_output_pin(conf):
-    return exp_gpio_pin_(GPIOOutputPin, conf, u'OUTPUT')
-
-
-def exp_gpio_input_pin(conf):
-    return exp_gpio_pin_(GPIOInputPin, conf, u'INPUT')
+def gpio_input_pin_expression(conf):
+    return generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT')
 
 
 def setup_mqtt_component(obj, config):
@@ -358,23 +567,8 @@ def setup_mqtt_component(obj, config):
         add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
     if CONF_AVAILABILITY in config:
         availability = config[CONF_AVAILABILITY]
-        exp = StructInitializer(
-            u'mqtt::Availability',
-            (u'topic', availability[CONF_TOPIC]),
-            (u'payload_available', availability[CONF_PAYLOAD_AVAILABLE]),
-            (u'payload_not_available', availability[CONF_PAYLOAD_NOT_AVAILABLE]),
-        )
-        add(obj.set_availability(exp))
-
-
-def exp_empty_optional(type):
-    return RawExpression(u'Optional<{}>()'.format(type))
-
-
-def exp_optional(type, value):
-    if value is None:
-        return exp_empty_optional(type)
-    return value
+        add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
+                                 availability[CONF_PAYLOAD_NOT_AVAILABLE]))
 
 
 # shlex's quote for Python 2.7

esphomeyaml/mqtt.py

@@ -1,13 +1,17 @@
 from __future__ import print_function
 
+import hashlib
 import logging
 from datetime import datetime
 
 import paho.mqtt.client as mqtt
 
-from esphomeyaml.const import CONF_BROKER, CONF_DISCOVERY_PREFIX, CONF_ESPHOMEYAML, CONF_LOGGER, \
-    CONF_LOG_TOPIC, CONF_MQTT, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_TOPIC_PREFIX, \
+from esphomeyaml import core
+from esphomeyaml.const import CONF_BROKER, CONF_DISCOVERY_PREFIX, CONF_ESPHOMEYAML, \
+    CONF_LOG_TOPIC, \
+    CONF_MQTT, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_TOPIC_PREFIX, \
     CONF_USERNAME
+from esphomeyaml.helpers import color
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -35,20 +39,28 @@ def initialize(config, subscriptions, on_message, username, password, client_id)
     return 0
 
 
-def show_logs(config, topic=None, username=None, password=None, client_id=None):
+def show_logs(config, topic=None, username=None, password=None, client_id=None, escape=False):
     if topic is not None:
         pass  # already have topic
-    elif CONF_LOG_TOPIC in config.get(CONF_LOGGER, {}):
-        topic = config[CONF_LOGGER][CONF_LOG_TOPIC]
-    elif CONF_TOPIC_PREFIX in config[CONF_MQTT]:
-        topic = config[CONF_MQTT][CONF_TOPIC_PREFIX] + u'/debug'
+    elif CONF_MQTT in config:
+        conf = config[CONF_MQTT]
+        if CONF_LOG_TOPIC in conf:
+            topic = config[CONF_MQTT][CONF_LOG_TOPIC]
+        elif CONF_TOPIC_PREFIX in config[CONF_MQTT]:
+            topic = config[CONF_MQTT][CONF_TOPIC_PREFIX] + u'/debug'
+        else:
+            topic = config[CONF_ESPHOMEYAML][CONF_NAME] + u'/debug'
     else:
-        topic = config[CONF_ESPHOMEYAML][CONF_NAME] + u'/debug'
+        _LOGGER.error(u"MQTT isn't setup, can't start MQTT logs")
+        return 1
     _LOGGER.info(u"Starting log output from %s", topic)
 
     def on_message(client, userdata, msg):
-        time = datetime.now().time().strftime(u'[%H:%M:%S] ')
-        print(time + msg.payload)
+        time = datetime.now().time().strftime(u'[%H:%M:%S]')
+        message = msg.payload.decode('utf-8')
+        if escape:
+            message = message.replace('\033', '\\033')
+        print(time + message)
 
     return initialize(config, [topic], on_message, username, password, client_id)
 
@@ -67,3 +79,23 @@ def clear_topic(config, topic, username=None, password=None, client_id=None):
         client.publish(msg.topic, None, retain=True)
 
     return initialize(config, [topic], on_message, username, password, client_id)
+
+
+# From marvinroger/async-mqtt-client -> scripts/get-fingerprint/get-fingerprint.py
+def get_fingerprint(config):
+    import ssl
+
+    addr = config[CONF_MQTT][CONF_BROKER], config[CONF_MQTT][CONF_PORT]
+    _LOGGER.info("Getting fingerprint from %s:%s", addr[0], addr[1])
+    try:
+        cert_pem = ssl.get_server_certificate(addr)
+    except IOError as err:
+        _LOGGER.error("Unable to connect to server: %s", err)
+        return 1
+    cert_der = ssl.PEM_cert_to_DER_cert(cert_pem)
+
+    sha1 = hashlib.sha1(cert_der).hexdigest()
+
+    print(u"SHA1 Fingerprint: " + color('cyan', sha1))
+    print(u"Copy above string into mqtt.ssl_fingerprints section of {}".format(core.CONFIG_PATH))
+    return 0

esphomeyaml/pins.py

@@ -3,8 +3,9 @@ import logging
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, CONF_NUMBER, CONF_MODE, \
-    CONF_INVERTED
+from esphomeyaml import core
+from esphomeyaml.const import CONF_INVERTED, CONF_MODE, CONF_NUMBER, CONF_PCF8574, \
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,7 +21,7 @@ ESP8266_D1_PINS = dict(ESP8266_PINS, **{
     'D10': 15, 'D11': 13, 'D12': 14, 'D13': 14, 'D14': 4, 'D15': 5, 'LED': 2, 'SDA': 4, 'SCL': 5,
 })
 ESP8266_D1_MINI_PINS = dict(ESP8266_PINS, **{
-    'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 0, 'D5': 14, 'D6': 12, 'D7': 13, 'D8': 15, 'RX': 3,
+    'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 2, 'D5': 14, 'D6': 12, 'D7': 13, 'D8': 15, 'RX': 3,
     'TX': 1, 'LED': 2, 'SDA': 4, 'SCL': 5,
 })
 ESP8266_THING_PINS = dict(ESP8266_PINS, **{
@@ -63,7 +64,8 @@ ESP32_BOARD_TO_PINS = {
 
 def _translate_pin(value):
     if isinstance(value, dict) or value is None:
-        raise vol.Invalid(u"This option doesn't allow more complicated options like inverted.")
+        raise vol.Invalid(u"This variable only supports pin numbers, not full pin schemas "
+                          u"(with inverted and mode).")
     if isinstance(value, int):
         return value
     try:
@@ -71,33 +73,33 @@ def _translate_pin(value):
     except ValueError:
         pass
     if value.startswith('GPIO'):
-        return vol.Coerce(int)(value[len('GPIO'):])
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return vol.Coerce(int)(value[len('GPIO'):].strip())
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if value in ESP32_PINS:
             return ESP32_PINS[value]
-        if cv.BOARD not in ESP32_BOARD_TO_PINS:
+        if core.BOARD not in ESP32_BOARD_TO_PINS:
             raise vol.Invalid(u"ESP32: Unknown board {} with unknown "
-                              u"pin {}.".format(cv.BOARD, value))
-        if value not in ESP32_BOARD_TO_PINS[cv.BOARD]:
-            raise vol.Invalid(u"ESP32: Board {} doesn't have"
-                              u"pin {}".format(cv.BOARD, value))
-        return ESP32_BOARD_TO_PINS[cv.BOARD][value]
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+                              u"pin {}.".format(core.BOARD, value))
+        if value not in ESP32_BOARD_TO_PINS[core.BOARD]:
+            raise vol.Invalid(u"ESP32: Board {} doesn't have "
+                              u"pin {}".format(core.BOARD, value))
+        return ESP32_BOARD_TO_PINS[core.BOARD][value]
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         if value in ESP8266_PINS:
             return ESP8266_PINS[value]
-        if cv.BOARD not in ESP8266_BOARD_TO_PINS:
+        if core.BOARD not in ESP8266_BOARD_TO_PINS:
             raise vol.Invalid(u"ESP8266: Unknown board {} with unknown "
-                              u"pin {}.".format(cv.BOARD, value))
-        if value not in ESP8266_BOARD_TO_PINS[cv.BOARD]:
-            raise vol.Invalid(u"ESP8266: Board {} doesn't have"
-                              u"pin {}".format(cv.BOARD, value))
-        return ESP8266_BOARD_TO_PINS[cv.BOARD][value]
+                              u"pin {}.".format(core.BOARD, value))
+        if value not in ESP8266_BOARD_TO_PINS[core.BOARD]:
+            raise vol.Invalid(u"ESP8266: Board {} doesn't have "
+                              u"pin {}".format(core.BOARD, value))
+        return ESP8266_BOARD_TO_PINS[core.BOARD][value]
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
-def _validate_gpio_pin(value):
+def validate_gpio_pin(value):
     value = _translate_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if value < 0 or value > 39:
             raise vol.Invalid(u"ESP32: Invalid pin number: {}".format(value))
         if 6 <= value <= 11:
@@ -107,7 +109,7 @@ def _validate_gpio_pin(value):
             _LOGGER.warning(u"ESP32: Pin %s (20, 24, 28-31) can usually not be used. "
                             u"Be warned.", value)
         return value
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         if 6 <= value <= 11:
             _LOGGER.warning(u"ESP8266: Pin %s (6-11) might already be used by the "
                             u"flash interface. Be warned.", value)
@@ -118,35 +120,33 @@ def _validate_gpio_pin(value):
 
 
 def input_pin(value):
-    value = _validate_gpio_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    value = validate_gpio_pin(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         return value
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         return value
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
 def output_pin(value):
-    value = _validate_gpio_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    value = validate_gpio_pin(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if 34 <= value <= 39:
             raise vol.Invalid(u"ESP32: Pin {} (34-39) can only be used as "
                               u"input pins.".format(value))
         return value
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
-        if value == 16:
-            raise vol.Invalid(u"Pin {} doesn't support output mode".format(value))
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         return value
     raise vol.Invalid("Invalid ESP platform.")
 
 
 def analog_pin(value):
-    value = _validate_gpio_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    value = validate_gpio_pin(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if 32 <= value <= 39:  # ADC1
             return value
         raise vol.Invalid(u"ESP32: Only pins 32 though 39 support ADC.")
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         if value == 17:  # A0
             return value
         raise vol.Invalid(u"ESP8266: Only pin A0 (17) supports ADC.")
@@ -171,27 +171,51 @@ PIN_MODES_ESP32 = [
 
 def pin_mode(value):
     value = vol.All(vol.Coerce(str), vol.Upper)(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
-        return vol.Any(*PIN_MODES_ESP32)(value)
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
-        return vol.Any(*PIN_MODES_ESP8266)(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return cv.one_of(*PIN_MODES_ESP32)(value)
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+        return cv.one_of(*PIN_MODES_ESP8266)(value)
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
-GPIO_PIN_SCHEMA = vol.Schema({
-    vol.Required(CONF_NUMBER): gpio_pin,
-    vol.Required(CONF_MODE): pin_mode,
-    vol.Optional(CONF_INVERTED): cv.boolean,
-})
-
-GPIO_OUTPUT_PIN_SCHEMA = vol.Any(output_pin, vol.Schema({
+GPIO_FULL_OUTPUT_PIN_SCHEMA = vol.Schema({
     vol.Required(CONF_NUMBER): output_pin,
     vol.Optional(CONF_MODE): pin_mode,
     vol.Optional(CONF_INVERTED): cv.boolean,
-}))
+})
 
-GPIO_INPUT_PIN_SCHEMA = vol.Any(input_pin, vol.Schema({
-    vol.Required(CONF_NUMBER): input_pin,
+GPIO_FULL_INPUT_PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_NUMBER): output_pin,
     vol.Optional(CONF_MODE): pin_mode,
     vol.Optional(CONF_INVERTED): cv.boolean,
-}))
+})
+
+
+def shorthand_output_pin(value):
+    value = output_pin(value)
+    return {CONF_NUMBER: value}
+
+
+def shorthand_input_pin(value):
+    value = input_pin(value)
+    return {CONF_NUMBER: value}
+
+
+PCF8574_OUTPUT_PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_PCF8574): cv.variable_id,
+    vol.Required(CONF_NUMBER): vol.Coerce(int),
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, "OUTPUT"),
+    vol.Optional(CONF_INVERTED, default=False): cv.boolean,
+})
+
+PCF8574_INPUT_PIN_SCHEMA = PCF8574_OUTPUT_PIN_SCHEMA.extend({
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, vol.Any("INPUT", "INPUT_PULLUP")),
+})
+
+GPIO_INTERNAL_OUTPUT_PIN_SCHEMA = vol.Any(shorthand_output_pin, GPIO_FULL_OUTPUT_PIN_SCHEMA)
+
+GPIO_OUTPUT_PIN_SCHEMA = vol.Any(PCF8574_OUTPUT_PIN_SCHEMA, GPIO_INTERNAL_OUTPUT_PIN_SCHEMA)
+
+GPIO_INTERNAL_INPUT_PIN_SCHEMA = vol.Any(shorthand_input_pin, GPIO_FULL_INPUT_PIN_SCHEMA)
+
+GPIO_INPUT_PIN_SCHEMA = vol.Any(PCF8574_INPUT_PIN_SCHEMA, GPIO_INTERNAL_INPUT_PIN_SCHEMA)

esphomeyaml/wizard.py

@@ -3,13 +3,13 @@ from __future__ import print_function
 import codecs
 import os
 import unicodedata
-from time import sleep
 
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import mqtt
-from esphomeyaml.const import ESP_BOARDS_FOR_PLATFORM, ESP_PLATFORMS, ESP_PLATFORM_ESP32
+from esphomeyaml.const import ESP_BOARDS_FOR_PLATFORM, ESP_PLATFORMS, ESP_PLATFORM_ESP32, \
+    ESP_PLATFORM_ESP8266
 from esphomeyaml.helpers import color
 
 
@@ -71,6 +71,24 @@ logger:
 """
 
 
+def wizard_file(**kwargs):
+    config = BASE_CONFIG.format(**kwargs)
+
+    if kwargs['ota_password']:
+        config += "ota:\n  password: '{}'\n".format(kwargs['ota_password'])
+    else:
+        config += "ota:\n"
+
+    return config
+
+
+if os.getenv('ESPHOMEYAML_QUICKWIZARD', False):
+    def sleep(time):
+        pass
+else:
+    from time import sleep
+
+
 def print_step(step, big):
     print()
     print()
@@ -136,10 +154,10 @@ def wizard(path):
     print("Great! Your node is now called \"{}\".".format(color('cyan', name)))
     sleep(1)
     print_step(2, ESP_BIG)
-    print("Now I'd like to know which *board* you're using so that I can compile "
+    print("Now I'd like to know what microcontroller you're using so that I can compile "
           "firmwares for it.")
     print("Are you using an " + color('green', 'ESP32') + " or " +
-          color('green', 'ESP8266') + " based board?")
+          color('green', 'ESP8266') + " platform? (Choose ESP8266 for Sonoff devices)")
     while True:
         sleep(0.5)
         print()
@@ -163,6 +181,8 @@ def wizard(path):
     print("Next, I need to know what " + color('green', 'board') + " you're using.")
     sleep(0.5)
     print("Please go to {} and choose a board.".format(color('green', board_link)))
+    if platform == ESP_PLATFORM_ESP8266:
+        print("(Type " + color('green', 'esp01_1m') + " for Sonoff devices)")
     print()
     # Don't sleep because user needs to copy link
     if platform == ESP_PLATFORM_ESP32:
@@ -212,7 +232,7 @@ def wizard(path):
     sleep(0.75)
 
     print("Now please state the " + color('green', 'password') +
-          " of the WiFi network so that I can connect to it.")
+          " of the WiFi network so that I can connect to it (Leave empty for no password)")
     print()
     print("For example \"{}\"".format(color('bold_white', 'PASSWORD42')))
     sleep(0.5)
@@ -264,14 +284,10 @@ def wizard(path):
     print("Press ENTER for no password")
     ota_password = raw_input(color('bold_white', '(password): '))
 
-    config = BASE_CONFIG.format(name=name, platform=platform, board=board,
-                                ssid=ssid, psk=psk, broker=broker,
-                                mqtt_username=mqtt_username, mqtt_password=mqtt_password)
-
-    if ota_password:
-        config += "ota:\n  password: '{}'\n".format(ota_password)
-    else:
-        config += "ota:\n"
+    config = wizard_file(name=name, platform=platform, board=board,
+                         ssid=ssid, psk=psk, broker=broker,
+                         mqtt_username=mqtt_username, mqtt_password=mqtt_password,
+                         ota_password=ota_password)
 
     with codecs.open(path, 'w') as f_handle:
         f_handle.write(config)

esphomeyaml/writer.py

@@ -4,9 +4,11 @@ import codecs
 import errno
 import os
 
-from esphomeyaml.config import get_component
-from esphomeyaml.const import CONF_BOARD, CONF_ESPHOMEYAML, CONF_LIBRARY_URI, CONF_LOGGER, \
-    CONF_NAME, CONF_PLATFORM, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
+from esphomeyaml import core
+from esphomeyaml.config import iter_components
+from esphomeyaml.const import CONF_BOARD, CONF_BOARD_FLASH_MODE, CONF_ESPHOMEYAML, \
+    CONF_LIBRARY_URI, \
+    CONF_NAME, CONF_PLATFORM, CONF_USE_BUILD_FLAGS, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
 from esphomeyaml.core import ESPHomeYAMLError
 
 CPP_AUTO_GENERATE_BEGIN = u'// ========== AUTO GENERATED CODE BEGIN ==========='
@@ -28,7 +30,7 @@ void setup() {
 
 void loop() {
   App.loop();
-  delay(1);
+  delay(16);
 }
 """)
 
@@ -50,9 +52,10 @@ platform = {platform}
 board = {board}
 framework = arduino
 lib_deps =
-    {esphomeyaml_uri}
+    {lib_deps}
     ${{common.lib_deps}}
-build_flags ={build_flags}
+build_flags =
+    {build_flags}
     ${{common.build_flags}}
 """
 
@@ -62,19 +65,63 @@ PLATFORM_TO_PLATFORMIO = {
 }
 
 
+def get_build_flags(config, key):
+    build_flags = set()
+    for _, component, conf in iter_components(config):
+        if not hasattr(component, key):
+            continue
+        flags = getattr(component, key)
+        if callable(flags):
+            flags = flags(conf)
+        if flags is None:
+            continue
+        if isinstance(flags, (str, unicode)):
+            flags = [flags]
+        build_flags |= set(flags)
+    return build_flags
+
+
 def get_ini_content(config):
+    platform = config[CONF_ESPHOMEYAML][CONF_PLATFORM]
+    if platform in PLATFORM_TO_PLATFORMIO:
+        platform = PLATFORM_TO_PLATFORMIO[platform]
     options = {
         u'env': config[CONF_ESPHOMEYAML][CONF_NAME],
-        u'platform': PLATFORM_TO_PLATFORMIO[config[CONF_ESPHOMEYAML][CONF_PLATFORM]],
+        u'platform': platform,
         u'board': config[CONF_ESPHOMEYAML][CONF_BOARD],
-        u'esphomeyaml_uri': config[CONF_ESPHOMEYAML][CONF_LIBRARY_URI],
         u'build_flags': u'',
     }
-    if CONF_LOGGER in config:
-        build_flags = get_component(CONF_LOGGER).get_build_flags(config[CONF_LOGGER])
-        if build_flags:
-            options[u'build_flags'] = u'\n    ' + build_flags
-    return INI_CONTENT_FORMAT.format(**options)
+    build_flags = set()
+    if config[CONF_ESPHOMEYAML][CONF_USE_BUILD_FLAGS]:
+        build_flags |= get_build_flags(config, 'build_flags')
+        build_flags |= get_build_flags(config, 'BUILD_FLAGS')
+        build_flags.add(u"-DESPHOMEYAML_USE")
+    build_flags |= get_build_flags(config, 'required_build_flags')
+    build_flags |= get_build_flags(config, 'REQUIRED_BUILD_FLAGS')
+
+    # avoid changing build flags order
+    build_flags = sorted(list(build_flags))
+    if build_flags:
+        options[u'build_flags'] = u'\n    '.join(build_flags)
+
+    lib_deps = set()
+    lib_deps.add(config[CONF_ESPHOMEYAML][CONF_LIBRARY_URI])
+    lib_deps |= get_build_flags(config, 'LIB_DEPS')
+    lib_deps |= get_build_flags(config, 'lib_deps')
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        lib_deps |= {
+            'Preferences',  # Preferences helper
+        }
+    # avoid changing build flags order
+    lib_deps = sorted(x for x in lib_deps if x)
+    if lib_deps:
+        options[u'lib_deps'] = u'\n    '.join(lib_deps)
+
+    content = INI_CONTENT_FORMAT.format(**options)
+    if CONF_BOARD_FLASH_MODE in config[CONF_ESPHOMEYAML]:
+        flash_mode = config[CONF_ESPHOMEYAML][CONF_BOARD_FLASH_MODE]
+        content += "board_flash_mode = {}\n".format(flash_mode)
+    return content
 
 
 def mkdir_p(path):

esphomeyaml/yaml_util.py

@@ -1,13 +1,14 @@
 from __future__ import print_function
+
 import codecs
 import fnmatch
 import logging
-from collections import OrderedDict
 import os
+from collections import OrderedDict
 
 import yaml
 
-from esphomeyaml.core import ESPHomeYAMLError, HexInt, IPAddress
+from esphomeyaml.core import ESPHomeYAMLError, HexInt, IPAddress, Lambda, MACAddress, TimePeriod
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,7 +30,7 @@ class NodeStrClass(unicode):
     pass
 
 
-class SafeLineLoader(yaml.SafeLoader):
+class SafeLineLoader(yaml.SafeLoader):  # pylint: disable=too-many-ancestors
     """Loader class that keeps track of line numbers."""
 
     def compose_node(self, parent, index):
@@ -79,9 +80,8 @@ def _ordered_dict(loader, node):
 
         if key in seen:
             fname = getattr(loader.stream, 'name', '')
-            _LOGGER.error(
-                u'YAML file %s contains duplicate key "%s". '
-                u'Check lines %d and %d.', fname, key, seen[key], line)
+            raise ESPHomeYAMLError(u'YAML file {} contains duplicate key "{}". '
+                                   u'Check lines {} and {}.'.format(fname, key, seen[key], line))
         seen[key] = line
 
     return _add_reference(OrderedDict(nodes), loader, node)
@@ -104,7 +104,7 @@ def _add_reference(obj, loader, node):
     return obj
 
 
-def _env_var_yaml(loader, node):
+def _env_var_yaml(_, node):
     """Load environment variables and embed it into the configuration YAML."""
     args = node.value.split()
 
@@ -194,6 +194,10 @@ def _secret_yaml(loader, node):
     return secrets[node.value]
 
 
+def _lambda(loader, node):
+    return Lambda(unicode(node.value))
+
+
 yaml.SafeLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _ordered_dict)
 yaml.SafeLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG, _construct_seq)
 yaml.SafeLoader.add_constructor('!env_var', _env_var_yaml)
@@ -205,6 +209,7 @@ yaml.SafeLoader.add_constructor('!include_dir_merge_list',
 yaml.SafeLoader.add_constructor('!include_dir_named', _include_dir_named_yaml)
 yaml.SafeLoader.add_constructor('!include_dir_merge_named',
                                 _include_dir_merge_named_yaml)
+yaml.SafeLoader.add_constructor('!lambda', _lambda)
 
 
 # From: https://gist.github.com/miracle2k/3184458
@@ -235,21 +240,45 @@ def represent_odict(dump, tag, mapping, flow_style=None):
     return node
 
 
-def unicode_representer(dumper, uni):
+def unicode_representer(_, uni):
     node = yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=uni)
     return node
 
 
-def hex_int_representer(dumper, data):
+def hex_int_representer(_, data):
     node = yaml.ScalarNode(tag=u'tag:yaml.org,2002:int', value=str(data))
     return node
 
 
-def ipaddress_representer(dumper, data):
+def stringify_representer(_, data):
     node = yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=str(data))
     return node
 
 
+TIME_PERIOD_UNIT_MAP = {
+    'microseconds': 'us',
+    'milliseconds': 'ms',
+    'seconds': 's',
+    'minutes': 'min',
+    'hours': 'h',
+    'days': 'd',
+}
+
+
+def represent_time_period(dumper, data):
+    dictionary = data.as_dict()
+    if len(dictionary) == 1:
+        unit, value = dictionary.popitem()
+        out = '{}{}'.format(value, TIME_PERIOD_UNIT_MAP[unit])
+        return yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=out)
+    return represent_odict(dumper, 'tag:yaml.org,2002:map', dictionary)
+
+
+def represent_lambda(_, data):
+    node = yaml.ScalarNode(tag='!lambda', value=data.value, style='>')
+    return node
+
+
 yaml.SafeDumper.add_representer(
     OrderedDict,
     lambda dumper, value:
@@ -264,4 +293,7 @@ yaml.SafeDumper.add_representer(
 
 yaml.SafeDumper.add_representer(unicode, unicode_representer)
 yaml.SafeDumper.add_representer(HexInt, hex_int_representer)
-yaml.SafeDumper.add_representer(IPAddress, ipaddress_representer)
+yaml.SafeDumper.add_representer(IPAddress, stringify_representer)
+yaml.SafeDumper.add_representer(MACAddress, stringify_representer)
+yaml.SafeDumper.add_multi_representer(TimePeriod, represent_time_period)
+yaml.SafeDumper.add_multi_representer(Lambda, represent_lambda)

pylintrc

@@ -14,6 +14,8 @@ disable=
   too-many-arguments,
   too-many-return-statements,
   duplicate-code,
+  invalid-name,
+  cyclic-import,
 
 
 additional-builtins=

repository.json

@@ -0,0 +1,5 @@
+{
+  "name": "esphomeyaml HassIO Add-On Repository",
+  "url": "https://github.com/OttoWinter/esphomeyaml",
+  "maintainer": "Otto Winter <contact@otto-winter.com>"
+}