Bump version to v1.12.0

* Update Hassio base image to 1.4.1

* Fix rotary encoder typo

Fixes https://github.com/esphome/issues/issues/136

.dockerignore

@@ -106,3 +106,5 @@ venv.bak/
 config/
 examples/
 Dockerfile
+.git/
+tests/build/

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,14 @@
+## Description:
+
+
+**Related issue (if applicable):** fixes <link to issue>
+
+**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>
+**Pull request in [esphome-core](https://github.com/esphome/esphome-core) with C++ framework changes (if applicable):** esphome/esphome-core#<esphome-core PR number goes here>
+
+## Checklist:
+  - [ ] The code change is tested and works locally.
+  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).
+
+If user exposed functionality or configuration variables are added/changed:
+  - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

.github/issue-close-app.yml

@@ -0,0 +1,7 @@
+comment: >-
+  https://github.com/esphome/esphome/issues/430
+issueConfigs:
+- content:
+  - "OTHERWISE THE ISSUE WILL BE CLOSED AUTOMATICALLY"
+
+caseInsensitive: false

.gitignore

@@ -104,3 +104,5 @@ venv.bak/
 .mypy_cache/
 
 config/
+tests/build/
+tests/.esphome/

.gitlab-ci.yml

@@ -0,0 +1,347 @@
+---
+# Based on https://gitlab.com/hassio-addons/addon-node-red/blob/master/.gitlab-ci.yml
+variables:
+  DOCKER_DRIVER: overlay2
+  DOCKER_HOST: tcp://docker:2375/
+
+stages:
+  - lint
+  - test
+  - deploy
+
+.lint: &lint
+  image: esphome/esphome-base-amd64
+  stage: lint
+  before_script:
+    - pip install -e .
+    - pip install flake8==3.6.0 pylint==1.9.4 pillow
+  tags:
+    - docker
+
+.test: &test
+  image: esphome/esphome-base-amd64
+  stage: test
+  before_script:
+    - pip install -e .
+  tags:
+    - docker
+  variables:
+    TZ: UTC
+
+.docker-base: &docker-base
+  image: esphome/esphome-base-builder
+  before_script:
+    - docker info
+    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
+  script:
+    - docker run --rm --privileged hassioaddons/qemu-user-static:latest
+    - TAG="${CI_COMMIT_TAG#v}"
+    - TAG="${TAG:-${CI_COMMIT_SHA:0:7}}"
+    - echo "Tag ${TAG}"
+
+    - |
+      if [[ "${IS_HASSIO}" == "YES" ]]; then
+        BUILD_FROM=esphome/esphome-hassio-base-${BUILD_ARCH}:1.4.1
+        BUILD_TO=esphome/esphome-hassio-${BUILD_ARCH}
+        DOCKERFILE=docker/Dockerfile.hassio
+      else
+        BUILD_FROM=esphome/esphome-base-${BUILD_ARCH}:1.4.1
+        if [[ "${BUILD_ARCH}" == "amd64" ]]; then
+          BUILD_TO=esphome/esphome
+        else
+          BUILD_TO=esphome/esphome-${BUILD_ARCH}
+        fi
+        DOCKERFILE=docker/Dockerfile
+      fi
+
+    - |
+      docker build \
+        --build-arg "BUILD_FROM=${BUILD_FROM}" \
+        --build-arg "BUILD_VERSION=${TAG}" \
+        --tag "${BUILD_TO}:${TAG}" \
+        --file "${DOCKERFILE}" \
+        .
+    - |
+      if [[ "${RELEASE}" = "YES" ]]; then
+        echo "Pushing to ${BUILD_TO}:${TAG}"
+        docker push "${BUILD_TO}:${TAG}"
+      fi
+    - |
+      if [[ "${LATEST}" = "YES" ]]; then
+        echo "Pushing to :latest"
+        docker tag ${BUILD_TO}:${TAG} ${BUILD_TO}:latest
+        docker push ${BUILD_TO}:latest
+      fi
+    - |
+      if [[ "${BETA}" = "YES" ]]; then
+        echo "Pushing to :beta"
+        docker tag \
+          ${BUILD_TO}:${TAG} \
+          ${BUILD_TO}:beta
+        docker push ${BUILD_TO}:beta
+      fi
+    - |
+      if [[ "${DEV}" = "YES" ]]; then
+        echo "Pushing to :dev"
+        docker tag \
+          ${BUILD_TO}:${TAG} \
+          ${BUILD_TO}:dev
+        docker push ${BUILD_TO}:dev
+      fi
+  services:
+    - docker:dind
+  tags:
+    - docker
+  stage: deploy
+
+flake8:
+  <<: *lint
+  script:
+    - flake8 esphome
+
+pylint:
+  <<: *lint
+  script:
+    - pylint esphome
+
+test1:
+  <<: *test
+  script:
+    - esphome tests/test1.yaml compile
+
+test2:
+  <<: *test
+  script:
+    - esphome tests/test2.yaml compile
+
+test3:
+  <<: *test
+  script:
+    - esphome tests/test3.yaml compile
+
+.deploy-pypi: &deploy-pypi
+  stage: deploy
+  image: python:2.7
+  before_script:
+  - pip install -e .
+  - pip install twine
+  script:
+  - python setup.py sdist bdist_wheel
+  - twine upload dist/*
+  tags:
+  - docker
+
+deploy-release:pypi:
+  <<: *deploy-pypi
+  only:
+    - /^v\d+\.\d+\.\d+$/
+  except:
+    - /^(?!master).+@/
+
+deploy-beta:pypi:
+  <<: *deploy-pypi
+  only:
+    - /^v\d+\.\d+\.\d+b\d+$/
+  except:
+    - /^(?!rc).+@/
+
+.latest: &latest
+  <<: *docker-base
+  only:
+  - /^v([0-9\.]+)$/
+  except:
+  - branches
+
+.latest-vars: &latest-vars
+  RELEASE: YES
+  LATEST: YES
+  # Also push to beta tag
+  BETA: YES
+
+.beta: &beta
+  <<: *docker-base
+  only:
+  - /^v([0-9\.]+b\d+)$/
+  except:
+  - branches
+
+.beta-vars: &beta-vars
+  RELEASE: YES
+  BETA: YES
+
+.dev: &dev
+  <<: *docker-base
+  only:
+  - dev
+
+.dev-vars: &dev-vars
+  DEV: YES
+
+#aarch64-beta-docker:
+#  <<: *beta
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "NO"
+#    RELEASE: "YES"
+#aarch64-beta-hassio:
+#  <<: *beta
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "YES"
+#    RELEASE: "YES"
+#aarch64-dev-docker:
+#  <<: *dev
+#  variables:
+#    BUILD_ARCH: aarch64
+#    DEV: "YES"
+#    IS_HASSIO: "NO"
+#aarch64-dev-hassio:
+#  <<: *dev
+#  variables:
+#    BUILD_ARCH: aarch64
+#    DEV: "YES"
+#    IS_HASSIO: "YES"
+#aarch64-latest-docker:
+#  <<: *latest
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "NO"
+#    LATEST: "YES"
+#    RELEASE: "YES"
+#aarch64-latest-hassio:
+#  <<: *latest
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "YES"
+#    LATEST: "YES"
+#    RELEASE: "YES"
+amd64-beta-docker:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "NO"
+    RELEASE: "YES"
+amd64-beta-hassio:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "YES"
+    RELEASE: "YES"
+amd64-dev-docker:
+  <<: *dev
+  variables:
+    BUILD_ARCH: amd64
+    DEV: "YES"
+    IS_HASSIO: "NO"
+amd64-dev-hassio:
+  <<: *dev
+  variables:
+    BUILD_ARCH: amd64
+    DEV: "YES"
+    IS_HASSIO: "YES"
+amd64-latest-docker:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "NO"
+    LATEST: "YES"
+    RELEASE: "YES"
+amd64-latest-hassio:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "YES"
+    LATEST: "YES"
+    RELEASE: "YES"
+armhf-beta-docker:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "NO"
+    RELEASE: "YES"
+armhf-beta-hassio:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "YES"
+    RELEASE: "YES"
+armhf-dev-docker:
+  <<: *dev
+  variables:
+    BUILD_ARCH: armhf
+    DEV: "YES"
+    IS_HASSIO: "NO"
+armhf-dev-hassio:
+  <<: *dev
+  variables:
+    BUILD_ARCH: armhf
+    DEV: "YES"
+    IS_HASSIO: "YES"
+armhf-latest-docker:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "NO"
+    LATEST: "YES"
+    RELEASE: "YES"
+armhf-latest-hassio:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "YES"
+    LATEST: "YES"
+    RELEASE: "YES"
+i386-beta-docker:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "NO"
+    RELEASE: "YES"
+i386-beta-hassio:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "YES"
+    RELEASE: "YES"
+i386-dev-docker:
+  <<: *dev
+  variables:
+    BUILD_ARCH: i386
+    DEV: "YES"
+    IS_HASSIO: "NO"
+i386-dev-hassio:
+  <<: *dev
+  variables:
+    BUILD_ARCH: i386
+    DEV: "YES"
+    IS_HASSIO: "YES"
+i386-latest-docker:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "NO"
+    LATEST: "YES"
+    RELEASE: "YES"
+i386-latest-hassio:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "YES"
+    LATEST: "YES"
+    RELEASE: "YES"

.travis.yml

@@ -1,10 +1,38 @@
 sudo: false
 language: python
-python:
-  - "2.7"
-install:
-  - pip install -r requirements.txt
-  - pip install flake8==3.5.0 pylint==1.8.4
-script:
- - flake8 esphomeyaml
- - pylint esphomeyaml
+
+cache:
+  directories:
+    - "~/.platformio"
+    - "$TRAVIS_BUILD_DIR/tests/build/test1/.piolibdeps"
+    - "$TRAVIS_BUILD_DIR/tests/build/test2/.piolibdeps"
+    - "$TRAVIS_BUILD_DIR/tests/build/test3/.piolibdeps"
+
+matrix:
+  fast_finish: true
+  include:
+    - python: "2.7"
+      env: TARGET=Lint2.7
+      install: pip install -e . && pip install flake8==3.6.0 pylint==1.9.4 pillow
+      script:
+        - flake8 esphome
+        - pylint esphome
+    - python: "3.5.3"
+      env: TARGET=Lint3.5
+      install: pip install -U https://github.com/platformio/platformio-core/archive/develop.zip && pip install -e . && pip install flake8==3.6.0 pylint==2.3.0 pillow
+      script:
+        - flake8 esphome
+        - pylint esphome
+    - python: "2.7"
+      env: TARGET=Test2.7
+      install: pip install -e . && pip install flake8==3.6.0 pylint==1.9.4 pillow
+      script:
+        - esphome tests/test1.yaml compile
+        - esphome tests/test2.yaml compile
+        - esphome tests/test3.yaml compile
+    #- python: "3.5.3"
+    #  env: TARGET=Test3.5
+    #  install: pip install -U https://github.com/platformio/platformio-core/archive/develop.zip && pip install -e . && pip install flake8==3.6.0 pylint==2.3.0 pillow
+    #  script:
+    #    - esphome tests/test1.yaml compile
+    #    - esphome tests/test2.yaml compile

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@otto-winter.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,18 @@
+# Contributing to ESPHome
+
+This python project is responsible for reading in YAML configuration files,
+converting them to C++ code. This code is then converted to a platformio project and compiled
+with [esphome-core](https://github.com/esphome/esphome-core), the C++ framework behind the project.
+
+For a detailed guide, please see https://esphome.io/guides/contributing.html#contributing-to-esphomeyaml
+
+Things to note when contributing:
+
+ - Please test your changes :)
+ - If a new feature is added or an existing user-facing feature is changed, you should also 
+   update the [docs](https://github.com/esphome/esphome-docs). See [contributing to esphome-docs](https://esphome.io/guides/contributing.html#contributing-to-esphomedocs)
+   for more information.
+ - Please also update the tests in the `tests/` folder. You can do so by just adding a line in one of the YAML files
+   which checks if your new feature compiles correctly.
+ - Sometimes I will let pull requests linger because I'm not 100% sure about them. Please feel free to ping
+   me after some time.

Dockerfile

@@ -1,20 +0,0 @@
-FROM python:2.7
-MAINTAINER Otto Winter <contact@otto-winter.com>
-
-ENV ESPHOMEYAML_OTA_HOST_PORT=6123
-EXPOSE 6123
-VOLUME /config
-WORKDIR /usr/src/app
-
-COPY requirements.txt /usr/src/app/
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY docker/platformio.ini /usr/src/app/
-RUN platformio settings set enable_telemetry No && \
-    platformio run -e espressif32 -e espressif8266; exit 0
-
-COPY . .
-RUN pip install -e .
-
-WORKDIR /config
-ENTRYPOINT ["esphomeyaml"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Otto Winter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+include README.md
+include esphome/dashboard/templates/*.html
+include esphome/dashboard/static/*.js
+include esphome/dashboard/static/*.css
+include esphome/dashboard/static/*.ico

README.md

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

docker/Dockerfile

@@ -0,0 +1,10 @@
+ARG BUILD_FROM=esphome/esphome-base-amd64:1.4.1
+FROM ${BUILD_FROM}
+
+COPY . .
+RUN \
+    pip2 install --no-cache-dir --no-binary :all: -e .
+
+WORKDIR /config
+ENTRYPOINT ["esphome"]
+CMD ["/config", "dashboard"]

docker/Dockerfile.hassio

@@ -0,0 +1,20 @@
+ARG BUILD_FROM=esphome/esphome-hassio-base-amd64:1.4.1
+FROM ${BUILD_FROM}
+
+# Copy root filesystem
+COPY docker/rootfs/ /
+COPY setup.py setup.cfg MANIFEST.in /opt/esphome/
+COPY esphome /opt/esphome/esphome
+
+RUN \
+    pip2 install --no-cache-dir --no-binary :all: -e /opt/esphome
+
+# Build arguments
+ARG BUILD_VERSION=dev
+
+# Labels
+LABEL \
+    io.hass.name="ESPHome" \
+    io.hass.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
+    io.hass.type="addon" \
+    io.hass.version=${BUILD_VERSION}

docker/Dockerfile.lint

@@ -0,0 +1,6 @@
+FROM python:2.7
+
+COPY requirements.txt /requirements.txt
+
+RUN pip install -r /requirements.txt && \
+    pip install flake8==3.6.0 pylint==1.9.4 pillow

docker/Dockerfile.test

@@ -0,0 +1,21 @@
+FROM ubuntu:bionic
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        python \
+        python-pip \
+        python-setuptools \
+        python-pil \
+        git \
+    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/*rm -rf /var/lib/apt/lists/* /tmp/* && \
+    pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No && \
+    platformio settings set check_libraries_interval 1000000 && \
+    platformio settings set check_platformio_interval 1000000 && \
+    platformio settings set check_platforms_interval 1000000
+
+COPY docker/platformio.ini /pio/platformio.ini
+RUN platformio run -d /pio; rm -rf /pio
+
+COPY requirements.txt /requirements.txt
+
+RUN pip install --no-cache-dir -r /requirements.txt

docker/hooks/build

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# the Docker repository tag being built.
+declare CACHE_TAG
+echo "CACHE_TAG: ${CACHE_TAG}"
+# the name and tag of the Docker repository being built. (This variable is a combination of DOCKER_REPO:CACHE_TAG.)
+declare IMAGE_NAME
+echo "IMAGE_NAME: ${IMAGE_NAME}"
+# the architecture to build
+declare BUILD_ARCH
+echo "BUILD_ARCH: ${BUILD_ARCH}"
+# whether this is a hassio build
+declare IS_HASSIO
+echo "IS_HASSIO: ${IS_HASSIO}"
+echo "PWD: $PWD"
+
+if [[ ${IS_HASSIO} = "YES" ]]; then
+    docker build \
+      --build-arg "BUILD_FROM=esphome/esphome-hassio-base-${BUILD_ARCH}:1.4.1" \
+      --build-arg "BUILD_VERSION=${CACHE_TAG}" \
+      -t "${IMAGE_NAME}" -f ../docker/Dockerfile.hassio ..
+else
+    docker build \
+      --build-arg "BUILD_FROM=esphome/esphome-base-${BUILD_ARCH}:1.4.1" \
+      -t "${IMAGE_NAME}" -f ../docker/Dockerfile ..
+fi

docker/hooks/pre_build

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+# the architecture to build
+declare BUILD_ARCH
+
+echo "BUILD_ARCH: ${BUILD_ARCH}"
+
+if [[ ${BUILD_ARCH} = "amd64" ]]; then
+    echo "No qemu required..."
+    exit 0
+fi
+if [[ ${BUILD_ARCH} = "i386" ]]; then
+    echo "No qemu required..."
+    exit 0
+fi
+
+echo "Installing qemu..."
+docker run --rm --privileged multiarch/qemu-user-static:register --reset

docker/platformio.ini

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

docker/rootfs/etc/cont-init.d/10-requirements.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files check if all user configuration requirements are met
+# ==============================================================================
+
+# Check SSL requirements, if enabled
+if bashio::config.true 'ssl'; then
+    if ! bashio::config.has_value 'certfile'; then
+        bashio::fatal 'SSL is enabled, but no certfile was specified.'
+        bashio::exit.nok
+    fi
+
+    if ! bashio::config.has_value 'keyfile'; then
+        bashio::fatal 'SSL is enabled, but no keyfile was specified'
+        bashio::exit.nok
+    fi
+
+
+    certfile="/ssl/$(bashio::config 'certfile')"
+    keyfile="/ssl/$(bashio::config 'keyfile')"
+
+    if ! bashio::fs.file_exists "${certfile}"; then
+        if ! bashio::fs.file_exists "${keyfile}"; then
+            # Both files are missing, let's print a friendlier error message
+            bashio::log.fatal 'You enabled encrypted connections using the "ssl": true option.'
+            bashio::log.fatal "However, the SSL files '${certfile}' and '${keyfile}'"
+            bashio::log.fatal "were not found. If you're using Hass.io on your local network and don't want"
+            bashio::log.fatal 'to encrypt connections to the ESPHome dashboard, you can manually disable'
+            bashio::log.fatal 'SSL by setting "ssl" to false."'
+            bashio::exit.nok
+        fi
+        bashio::log.fatal "The configured certfile '${certfile}' was not found."
+        bashio::exit.nok
+    fi
+
+    if ! bashio::fs.file_exists "/ssl/$(bashio::config 'keyfile')"; then
+        bashio::log.fatal "The configured keyfile '${keyfile}' was not found."
+        bashio::exit.nok
+    fi
+fi

docker/rootfs/etc/cont-init.d/20-nginx.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Configures NGINX for use with ESPHome
+# ==============================================================================
+
+declare certfile
+declare keyfile
+declare port
+
+mkdir -p /var/log/nginx
+
+# Enable SSL
+if bashio::config.true 'ssl'; then
+    rm /etc/nginx/nginx.conf
+    mv /etc/nginx/nginx-ssl.conf /etc/nginx/nginx.conf
+
+    certfile=$(bashio::config 'certfile')
+    keyfile=$(bashio::config 'keyfile')
+
+    sed -i "s/%%certfile%%/${certfile}/g" /etc/nginx/nginx.conf
+    sed -i "s/%%keyfile%%/${keyfile}/g" /etc/nginx/nginx.conf
+fi
+
+port=$(bashio::config 'port')
+sed -i "s/%%port%%/${port}/g" /etc/nginx/nginx.conf

docker/rootfs/etc/cont-init.d/30-esphome.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files installs the user ESPHome version if specified
+# ==============================================================================
+
+declare esphome_version
+
+if bashio::config.has_value 'esphome_version'; then
+    esphome_version=$(bashio::config 'esphome_version')
+    full_url="https://github.com/esphome/esphome/archive/${esphome_version}.zip"
+    bashio::log.info "Installing esphome version '${esphome_version}' (${full_url})..."
+    pip2 install --no-cache-dir --no-binary :all: "${full_url}" \
+      || bashio::exit.nok "Failed installing esphome pinned version."
+fi

docker/rootfs/etc/cont-init.d/40-migrate.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files migrates the esphome config directory from the old path
+# ==============================================================================
+
+if [[ ! -d /config/esphome && -d /config/esphomeyaml ]]; then
+    echo "Moving config directory from /config/esphomeyaml to /config/esphome"
+    mv /config/esphomeyaml /config/esphome
+    mv /config/esphome/.esphomeyaml /config/esphome/.esphome
+fi

docker/rootfs/etc/nginx/nginx-ssl.conf

@@ -0,0 +1,62 @@
+worker_processes  1;
+pid /var/run/nginx.pid;
+error_log stderr;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    access_log         stdout;
+    include            mime.types;
+    default_type       application/octet-stream;
+    sendfile           on;
+    keepalive_timeout  65;
+
+    upstream esphome {
+        ip_hash;
+        server unix:/var/run/esphome.sock;
+    }
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        ''      close;
+    }
+
+    server {
+        server_name hassio.local;
+        listen %%port%% default_server ssl;
+        root /dev/null;
+
+        ssl_certificate /ssl/%%certfile%%;
+        ssl_certificate_key /ssl/%%keyfile%%;
+        ssl_protocols TLSv1.2;
+        ssl_prefer_server_ciphers on;
+        ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:DHE-RSA-AES256-SHA;
+        ssl_ecdh_curve secp384r1;
+        ssl_session_timeout  10m;
+        ssl_session_cache shared:SSL:10m;
+        ssl_session_tickets off;
+        ssl_stapling on;
+        ssl_stapling_verify on;
+
+        # Redirect http requests to https on the same port.
+        # https://rageagainstshell.com/2016/11/redirect-http-to-https-on-the-same-port-in-nginx/
+        error_page 497 https://$http_host$request_uri;
+
+        location / {
+            proxy_redirect off;
+            proxy_pass http://esphome;
+
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+            proxy_set_header Authorization "";
+
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Host $http_host;
+            proxy_set_header X-NginX-Proxy true;
+        }
+    }
+}

docker/rootfs/etc/nginx/nginx.conf

@@ -0,0 +1,46 @@
+worker_processes  1;
+pid /var/run/nginx.pid;
+error_log stderr;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    access_log         stdout;
+    include            mime.types;
+    default_type       application/octet-stream;
+    sendfile           on;
+    keepalive_timeout  65;
+
+    upstream esphome {
+        ip_hash;
+        server unix:/var/run/esphome.sock;
+    }
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        ''      close;
+    }
+
+    server {
+        server_name hassio.local;
+        listen %%port%% default_server;
+        root /dev/null;
+
+        location / {
+            proxy_redirect off;
+            proxy_pass http://esphome;
+
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+            proxy_set_header Authorization "";
+
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Host $http_host;
+            proxy_set_header X-NginX-Proxy true;
+        }
+    }
+}

docker/rootfs/etc/services.d/esphome/finish

@@ -0,0 +1,9 @@
+#!/usr/bin/execlineb -S0
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Take down the S6 supervision tree when ESPHome fails
+# ==============================================================================
+if -n { s6-test $# -ne 0 }
+if -n { s6-test ${1} -eq 256 }
+
+s6-svscanctl -t /var/run/s6/services

docker/rootfs/etc/services.d/esphome/run

@@ -0,0 +1,26 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Runs the ESPHome dashboard
+# ==============================================================================
+
+export ESPHOME_IS_HASSIO=true
+
+if bashio::config.true 'leave_front_door_open'; then
+    export DISABLE_HA_AUTHENTICATION=true
+fi
+
+if bashio::config.true 'streamer_mode'; then
+    export ESPHOME_STREAMER_MODE=true
+fi
+
+if bashio::config.true 'status_use_ping'; then
+    export ESPHOME_DASHBOARD_USE_PING=true
+fi
+
+if bashio::config.has_value 'relative_url'; then
+    export ESPHOME_DASHBOARD_RELATIVE_URL=$(bashio::config 'relative_url')
+fi
+
+bashio::log.info "Starting ESPHome dashboard..."
+exec esphome /config/esphome dashboard --socket /var/run/esphome.sock --hassio

docker/rootfs/etc/services.d/nginx/finish

@@ -0,0 +1,9 @@
+#!/usr/bin/execlineb -S0
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Take down the S6 supervision tree when NGINX fails
+# ==============================================================================
+if -n { s6-test $# -ne 0 }
+if -n { s6-test ${1} -eq 256 }
+
+s6-svscanctl -t /var/run/s6/services

docker/rootfs/etc/services.d/nginx/run

@@ -0,0 +1,8 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Runs the NGINX proxy
+# ==============================================================================
+
+bashio::log.info "Starting NGINX..."
+exec nginx -g "daemon off;"

esphome/__main__.py

@@ -0,0 +1,493 @@
+from __future__ import print_function
+
+import argparse
+from datetime import datetime
+import logging
+import os
+import random
+import sys
+
+from esphome import const, core_config, mqtt, platformio_api, wizard, writer, yaml_util
+from esphome.api.client import run_logs
+from esphome.config import get_component, iter_components, read_config, strip_default_ids
+from esphome.const import CONF_BAUD_RATE, CONF_BROKER, CONF_ESPHOME, CONF_LOGGER, \
+    CONF_USE_CUSTOM_CODE
+from esphome.core import CORE, EsphomeError
+from esphome.cpp_generator import Expression, RawStatement, add, statement
+from esphome.helpers import color, indent
+from esphome.py_compat import IS_PY2, safe_input, text_type
+from esphome.storage_json import StorageJSON, storage_path
+from esphome.util import run_external_command, run_external_process, safe_print, \
+    is_dev_esphome_version
+
+_LOGGER = logging.getLogger(__name__)
+
+PRE_INITIALIZE = ['esphome', 'logger', 'wifi', 'ethernet', 'ota', 'mqtt', 'web_server', 'api',
+                  'i2c']
+
+
+def get_serial_ports():
+    # from https://github.com/pyserial/pyserial/blob/master/serial/tools/list_ports.py
+    from serial.tools.list_ports import comports
+    result = []
+    for port, desc, info in comports():
+        if not port:
+            continue
+        if "VID:PID" in info:
+            result.append((port, desc))
+    result.sort(key=lambda x: x[0])
+    return result
+
+
+def choose_prompt(options):
+    if not options:
+        raise ValueError
+
+    if len(options) == 1:
+        return options[0][1]
+
+    safe_print(u"Found multiple options, please choose one:")
+    for i, (desc, _) in enumerate(options):
+        safe_print(u"  [{}] {}".format(i + 1, desc))
+
+    while True:
+        opt = safe_input('(number): ')
+        if opt in options:
+            opt = options.index(opt)
+            break
+        try:
+            opt = int(opt)
+            if opt < 1 or opt > len(options):
+                raise ValueError
+            break
+        except ValueError:
+            safe_print(color('red', u"Invalid option: '{}'".format(opt)))
+    return options[opt - 1][1]
+
+
+def choose_upload_log_host(default, check_default, show_ota, show_mqtt, show_api):
+    options = []
+    for res, desc in get_serial_ports():
+        options.append((u"{} ({})".format(res, desc), res))
+    if (show_ota and 'ota' in CORE.config) or (show_api and 'api' in CORE.config):
+        options.append((u"Over The Air ({})".format(CORE.address), CORE.address))
+        if default == 'OTA':
+            return CORE.address
+    if show_mqtt and 'mqtt' in CORE.config:
+        options.append((u"MQTT ({})".format(CORE.config['mqtt'][CONF_BROKER]), 'MQTT'))
+        if default == 'OTA':
+            return 'MQTT'
+    if default is not None:
+        return default
+    if check_default is not None and check_default in [opt[1] for opt in options]:
+        return check_default
+    return choose_prompt(options)
+
+
+def get_port_type(port):
+    if port.startswith('/') or port.startswith('COM'):
+        return 'SERIAL'
+    if port == 'MQTT':
+        return 'MQTT'
+    return 'NETWORK'
+
+
+def run_miniterm(config, port):
+    import serial
+    if CONF_LOGGER not in config:
+        _LOGGER.info("Logger is not enabled. Not starting UART logs.")
+        return
+    baud_rate = config['logger'][CONF_BAUD_RATE]
+    if baud_rate == 0:
+        _LOGGER.info("UART logging is disabled (baud_rate=0). Not starting UART logs.")
+    _LOGGER.info("Starting log output from %s with baud rate %s", port, baud_rate)
+
+    backtrace_state = False
+    with serial.Serial(port, baudrate=baud_rate) as ser:
+        while True:
+            try:
+                raw = ser.readline()
+            except serial.SerialException:
+                _LOGGER.error("Serial port closed!")
+                return
+            if IS_PY2:
+                line = raw.replace('\r', '').replace('\n', '')
+            else:
+                line = raw.replace(b'\r', b'').replace(b'\n', b'').decode('utf8',
+                                                                          'backslashreplace')
+            time = datetime.now().time().strftime('[%H:%M:%S]')
+            message = time + line
+            safe_print(message)
+
+            backtrace_state = platformio_api.process_stacktrace(
+                config, line, backtrace_state=backtrace_state)
+
+
+def write_cpp(config):
+    _LOGGER.info("Generating C++ source...")
+
+    CORE.add_job(core_config.to_code, config[CONF_ESPHOME], domain='esphome')
+    for domain in PRE_INITIALIZE:
+        if domain == CONF_ESPHOME or domain not in config:
+            continue
+        CORE.add_job(get_component(domain).to_code, config[domain], domain=domain)
+
+    for domain, component, conf in iter_components(config):
+        if domain in PRE_INITIALIZE or not hasattr(component, 'to_code'):
+            continue
+        CORE.add_job(component.to_code, conf, domain=domain)
+
+    CORE.flush_tasks()
+    add(RawStatement(''))
+    add(RawStatement(''))
+    all_code = []
+    for exp in CORE.expressions:
+        if not config[CONF_ESPHOME][CONF_USE_CUSTOM_CODE]:
+            if isinstance(exp, Expression) and not exp.required:
+                continue
+        all_code.append(text_type(statement(exp)))
+
+    writer.write_platformio_project()
+
+    code_s = indent('\n'.join(line.rstrip() for line in all_code))
+    writer.write_cpp(code_s)
+    return 0
+
+
+def compile_program(args, config):
+    _LOGGER.info("Compiling app...")
+    rc = platformio_api.run_compile(config, args.verbose)
+    if rc != 0 and CORE.is_dev_esphome_core_version and not is_dev_esphome_version():
+        _LOGGER.warning("You're using 'esphome_core_version: dev' but not using the "
+                        "dev version of the ESPHome tool.")
+        _LOGGER.warning("Expect compile errors if these versions are out of sync.")
+        _LOGGER.warning("Please install the dev version of ESPHome too when using "
+                        "'esphome_core_version: dev'.")
+        _LOGGER.warning(" - Hass.io: Install 'ESPHome (dev)' addon")
+        _LOGGER.warning(" - Docker: docker run [...] esphome/esphome:dev [...]")
+        _LOGGER.warning(" - PIP: pip install -U https://github.com/esphome/esphome/archive/dev.zip")
+    return rc
+
+
+def upload_using_esptool(config, port):
+    path = CORE.firmware_bin
+    cmd = ['esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
+           '--chip', 'esp8266', '--port', port, 'write_flash', '0x0', path]
+
+    if os.environ.get('ESPHOME_USE_SUBPROCESS') is None:
+        import esptool
+        # pylint: disable=protected-access
+        return run_external_command(esptool._main, *cmd)
+
+    return run_external_process(*cmd)
+
+
+def upload_program(config, args, host):
+    # if upload is to a serial port use platformio, otherwise assume ota
+    if get_port_type(host) == 'SERIAL':
+        if CORE.is_esp8266:
+            return upload_using_esptool(config, host)
+        return platformio_api.run_upload(config, args.verbose, host)
+
+    from esphome.components import ota
+    from esphome import espota2
+
+    if args.host_port is not None:
+        host_port = args.host_port
+    else:
+        host_port = int(os.getenv('ESPHOME_OTA_HOST_PORT', random.randint(10000, 60000)))
+
+    verbose = args.verbose
+    remote_port = ota.get_port(config)
+    password = ota.get_auth(config)
+
+    storage = StorageJSON.load(storage_path())
+    res = espota2.run_ota(host, remote_port, password, CORE.firmware_bin)
+    if res == 0:
+        if storage is not None and storage.use_legacy_ota:
+            storage.use_legacy_ota = False
+            storage.save(storage_path())
+        return res
+    if storage is not None and not storage.use_legacy_ota:
+        return res
+
+    _LOGGER.warning("OTA v2 method failed. Trying with legacy OTA...")
+    return espota2.run_legacy_ota(verbose, host_port, host, remote_port, password,
+                                  CORE.firmware_bin)
+
+
+def show_logs(config, args, port):
+    if 'logger' not in config:
+        raise EsphomeError("Logger is not configured!")
+    if get_port_type(port) == 'SERIAL':
+        run_miniterm(config, port)
+        return 0
+    if get_port_type(port) == 'NETWORK' and 'api' in config:
+        return run_logs(config, port)
+    if get_port_type(port) == 'MQTT' and 'mqtt' in config:
+        return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+
+    raise ValueError
+
+
+def clean_mqtt(config, args):
+    return mqtt.clear_topic(config, args.topic, args.username, args.password, args.client_id)
+
+
+def setup_log(debug=False):
+    log_level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(level=log_level)
+    fmt = "%(levelname)s %(message)s"
+    colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
+    datefmt = '%H:%M:%S'
+
+    logging.getLogger('urllib3').setLevel(logging.WARNING)
+
+    try:
+        from colorlog import ColoredFormatter
+        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
+            colorfmt,
+            datefmt=datefmt,
+            reset=True,
+            log_colors={
+                'DEBUG': 'cyan',
+                'INFO': 'green',
+                'WARNING': 'yellow',
+                'ERROR': 'red',
+                'CRITICAL': 'red',
+            }
+        ))
+    except ImportError:
+        pass
+
+
+def command_wizard(args):
+    return wizard.wizard(args.configuration)
+
+
+def command_config(args, config):
+    _LOGGER.info("Configuration is valid!")
+    if not args.verbose:
+        config = strip_default_ids(config)
+    safe_print(yaml_util.dump(config))
+    return 0
+
+
+def command_compile(args, config):
+    exit_code = write_cpp(config)
+    if exit_code != 0:
+        return exit_code
+    if args.only_generate:
+        _LOGGER.info(u"Successfully generated source code.")
+        return 0
+    exit_code = compile_program(args, config)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully compiled program.")
+    return 0
+
+
+def command_upload(args, config):
+    port = choose_upload_log_host(default=args.upload_port, check_default=None,
+                                  show_ota=True, show_mqtt=False, show_api=False)
+    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 = choose_upload_log_host(default=args.serial_port, check_default=None,
+                                  show_ota=False, show_mqtt=True, show_api=True)
+    return show_logs(config, args, port)
+
+
+def command_run(args, config):
+    exit_code = write_cpp(config)
+    if exit_code != 0:
+        return exit_code
+    exit_code = compile_program(args, config)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully compiled program.")
+    port = choose_upload_log_host(default=args.upload_port, check_default=None,
+                                  show_ota=True, show_mqtt=False, show_api=True)
+    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
+    port = choose_upload_log_host(default=args.upload_port, check_default=port,
+                                  show_ota=False, show_mqtt=True, show_api=True)
+    return show_logs(config, args, port)
+
+
+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):
+    safe_print(u"Version: {}".format(const.__version__))
+    return 0
+
+
+def command_clean(args, config):
+    try:
+        writer.clean_build()
+    except OSError as err:
+        _LOGGER.error("Error deleting build files: %s", err)
+        return 1
+    _LOGGER.info("Done!")
+    return 0
+
+
+def command_dashboard(args):
+    from esphome.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,
+    'clean': command_clean,
+}
+
+
+def parse_args(argv):
+    parser = argparse.ArgumentParser(prog='esphome')
+    parser.add_argument('-v', '--verbose', help="Enable verbose esphome logs.",
+                        action='store_true')
+    parser.add_argument('--dashboard', help="Internal flag to set if the command is run from the "
+                                            "dashboard.", action='store_true')
+    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.')
+
+    parser_compile = subparsers.add_parser('compile',
+                                           help='Read the configuration and compile a program.')
+    parser_compile.add_argument('--only-generate',
+                                help="Only generate source code, do not compile.",
+                                action='store_true')
+
+    parser_upload = subparsers.add_parser('upload', help='Validate the configuration '
+                                                         'and upload the latest binary.')
+    parser_upload.add_argument('--upload-port', help="Manually specify the upload port to use. "
+                                                     "For example /dev/cu.SLAB_USBtoUART.")
+    parser_upload.add_argument('--host-port', help="Specify the host port.", type=int)
+
+    parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
+                                                     'and show all MQTT logs.')
+    parser_logs.add_argument('--topic', help='Manually set the topic to subscribe to.')
+    parser_logs.add_argument('--username', help='Manually set the username.')
+    parser_logs.add_argument('--password', help='Manually set the password.')
+    parser_logs.add_argument('--client-id', help='Manually set the client id.')
+    parser_logs.add_argument('--serial-port', help="Manually specify a serial port to use"
+                                                   "For example /dev/cu.SLAB_USBtoUART.")
+
+    parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
+                                                   'upload it, and start MQTT logs.')
+    parser_run.add_argument('--upload-port', help="Manually specify the upload port/ip to use. "
+                                                  "For example /dev/cu.SLAB_USBtoUART.")
+    parser_run.add_argument('--host-port', help="Specify the host port to use for OTA", type=int)
+    parser_run.add_argument('--no-logs', help='Disable starting MQTT logs.',
+                            action='store_true')
+    parser_run.add_argument('--topic', help='Manually set the topic to subscribe to for logs.')
+    parser_run.add_argument('--username', help='Manually set the MQTT username for logs.')
+    parser_run.add_argument('--password', help='Manually set the MQTT password for logs.')
+    parser_run.add_argument('--client-id', help='Manually set the client id for logs.')
+
+    parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
+                                                            "retain messages.")
+    parser_clean.add_argument('--topic', help='Manually set the topic to subscribe to.')
+    parser_clean.add_argument('--username', help='Manually set the username.')
+    parser_clean.add_argument('--password', help='Manually set the password.')
+    parser_clean.add_argument('--client-id', help='Manually set the client id.')
+
+    subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
+                                         "you through setting up esphome.")
+
+    subparsers.add_parser('mqtt-fingerprint', help="Get the SSL fingerprint from a MQTT broker.")
+
+    subparsers.add_parser('version', help="Print the esphome version and exit.")
+
+    subparsers.add_parser('clean', help="Delete all temporary build files.")
+
+    dashboard = subparsers.add_parser('dashboard',
+                                      help="Create a simple web server for a dashboard.")
+    dashboard.add_argument("--port", help="The HTTP port to open connections on. Defaults to 6052.",
+                           type=int, default=6052)
+    dashboard.add_argument("--password", help="The optional password to require for all requests.",
+                           type=str, default='')
+    dashboard.add_argument("--open-ui", help="Open the dashboard UI in a browser.",
+                           action='store_true')
+    dashboard.add_argument("--hassio",
+                           help="Internal flag used to tell esphome is started as a Hass.io "
+                                "add-on.",
+                           action="store_true")
+    dashboard.add_argument("--socket",
+                           help="Make the dashboard serve under a unix socket", type=str)
+
+    return parser.parse_args(argv[1:])
+
+
+def run_esphome(argv):
+    args = parse_args(argv)
+    CORE.dashboard = args.dashboard
+
+    setup_log(args.verbose)
+    if args.command in PRE_CONFIG_ACTIONS:
+        try:
+            return PRE_CONFIG_ACTIONS[args.command](args)
+        except EsphomeError as e:
+            _LOGGER.error(e)
+            return 1
+
+    CORE.config_path = args.configuration
+
+    config = read_config(args.verbose)
+    if config is None:
+        return 1
+    CORE.config = config
+
+    if args.command in POST_CONFIG_ACTIONS:
+        try:
+            return POST_CONFIG_ACTIONS[args.command](args, config)
+        except EsphomeError as e:
+            _LOGGER.error(e)
+            return 1
+    safe_print(u"Unknown command {}".format(args.command))
+    return 1
+
+
+def main():
+    try:
+        return run_esphome(sys.argv)
+    except EsphomeError as e:
+        _LOGGER.error(e)
+        return 1
+    except KeyboardInterrupt:
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

esphome/api/api.proto

@@ -0,0 +1,330 @@
+syntax = "proto3";
+
+// The Home Assistant protocol is structured as a simple
+// TCP socket with short binary messages encoded in the protocol buffers format
+// First, a message in this protocol has a specific format:
+//  * VarInt denoting the size of the message object. (type is not part of this)
+//  * VarInt denoting the type of message.
+//  * The message object encoded as a ProtoBuf message
+
+// The connection is established in 4 steps:
+//  * First, the client connects to the server and sends a "Hello Request" identifying itself
+//  * The server responds with a "Hello Response" and selects the protocol version
+//  * After receiving this message, the client attempts to authenticate itself using
+//    the password and a "Connect Request"
+//  * The server responds with a "Connect Response" and notifies of invalid password.
+// If anything in this initial process fails, the connection must immediately closed
+// by both sides and _no_ disconnection message is to be sent.
+
+// Message sent at the beginning of each connection
+// Can only be sent by the client and only at the beginning of the connection
+message HelloRequest {
+  // Description of client (like User Agent)
+  // For example "Home Assistant"
+  // Not strictly necessary to send but nice for debugging
+  // purposes.
+  string client_info = 1;
+}
+
+// Confirmation of successful connection request.
+// Can only be sent by the server and only at the beginning of the connection
+message HelloResponse {
+  // The version of the API to use. The _client_ (for example Home Assistant) needs to check
+  // for compatibility and if necessary adopt to an older API.
+  // Major is for breaking changes in the base protocol - a mismatch will lead to immediate disconnect_client_
+  // Minor is for breaking changes in individual messages - a mismatch will lead to a warning message
+  uint32 api_version_major = 1;
+  uint32 api_version_minor = 2;
+
+  // A string identifying the server (ESP); like client info this may be empty
+  // and only exists for debugging/logging purposes.
+  // For example "ESPHome v1.10.0 on ESP8266"
+  string server_info = 3;
+}
+
+// Message sent at the beginning of each connection to authenticate the client
+// Can only be sent by the client and only at the beginning of the connection
+message ConnectRequest {
+  // The password to log in with
+  string password = 1;
+}
+
+// Confirmation of successful connection. After this the connection is available for all traffic.
+// Can only be sent by the server and only at the beginning of the connection
+message ConnectResponse {
+  bool invalid_password = 1;
+}
+
+// Request to close the connection.
+// Can be sent by both the client and server
+message DisconnectRequest {
+  // Do not close the connection before the acknowledgement arrives
+}
+
+message DisconnectResponse {
+  // Empty - Both parties are required to close the connection after this
+  // message has been received.
+}
+
+message PingRequest {
+  // Empty
+}
+
+message PingResponse {
+  // Empty
+}
+
+message DeviceInfoRequest {
+  // Empty
+}
+
+message DeviceInfoResponse {
+  bool uses_password = 1;
+
+  // The name of the node, given by "App.set_name()"
+  string name = 2;
+
+  // The mac address of the device. For example "AC:BC:32:89:0E:A9"
+  string mac_address = 3;
+
+  // A string describing the ESPHome version. For example "1.10.0"
+  string esphome_core_version = 4;
+
+  // A string describing the date of compilation, this is generated by the compiler
+  // and therefore may not be in the same format all the time.
+  // If the user isn't using esphome, this will also not be set.
+  string compilation_time = 5;
+
+  // The model of the board. For example NodeMCU
+  string model = 6;
+
+  bool has_deep_sleep = 7;
+}
+
+message ListEntitiesRequest {
+  // Empty
+}
+
+message ListEntitiesBinarySensorResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string device_class = 5;
+  bool is_status_binary_sensor = 6;
+}
+message ListEntitiesCoverResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  bool is_optimistic = 5;
+}
+message ListEntitiesFanResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  bool supports_oscillation = 5;
+  bool supports_speed = 6;
+}
+message ListEntitiesLightResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  bool supports_brightness = 5;
+  bool supports_rgb = 6;
+  bool supports_white_value = 7;
+  bool supports_color_temperature = 8;
+  float min_mireds = 9;
+  float max_mireds = 10;
+  repeated string effects = 11;
+}
+message ListEntitiesSensorResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  string unit_of_measurement = 6;
+  int32 accuracy_decimals = 7;
+}
+message ListEntitiesSwitchResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool optimistic = 6;
+}
+message ListEntitiesTextSensorResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+}
+message ListEntitiesDoneResponse {
+  // Empty
+}
+
+message SubscribeStatesRequest {
+  // Empty
+}
+message BinarySensorStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+}
+message CoverStateResponse {
+  fixed32 key = 1;
+  enum CoverState {
+    OPEN = 0;
+    CLOSED = 1;
+  }
+  CoverState state = 2;
+}
+enum FanSpeed {
+  LOW = 0;
+  MEDIUM = 1;
+  HIGH = 2;
+}
+message FanStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+  bool oscillating = 3;
+  FanSpeed speed = 4;
+}
+message LightStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+  float brightness = 3;
+  float red = 4;
+  float green = 5;
+  float blue = 6;
+  float white = 7;
+  float color_temperature = 8;
+  string effect = 9;
+}
+message SensorStateResponse {
+  fixed32 key = 1;
+  float state = 2;
+}
+message SwitchStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+}
+message TextSensorStateResponse {
+  fixed32 key = 1;
+  string state = 2;
+}
+
+message CoverCommandRequest {
+  fixed32 key = 1;
+  enum CoverCommand {
+    OPEN = 0;
+    CLOSE = 1;
+    STOP = 2;
+  }
+  bool has_state = 2;
+  CoverCommand command = 3;
+}
+message FanCommandRequest {
+  fixed32 key = 1;
+  bool has_state = 2;
+  bool state = 3;
+  bool has_speed = 4;
+  FanSpeed speed = 5;
+  bool has_oscillating = 6;
+  bool oscillating = 7;
+}
+message LightCommandRequest {
+  fixed32 key = 1;
+  bool has_state = 2;
+  bool state = 3;
+  bool has_brightness = 4;
+  float brightness = 5;
+  bool has_rgb = 6;
+  float red = 7;
+  float green = 8;
+  float blue = 9;
+  bool has_white = 10;
+  float white = 11;
+  bool has_color_temperature = 12;
+  float color_temperature = 13;
+  bool has_transition_length = 14;
+  uint32 transition_length = 15;
+  bool has_flash_length = 16;
+  uint32 flash_length = 17;
+  bool has_effect = 18;
+  string effect = 19;
+}
+message SwitchCommandRequest {
+  fixed32 key = 1;
+  bool state = 2;
+}
+
+enum LogLevel {
+  NONE = 0;
+  ERROR = 1;
+  WARN = 2;
+  INFO = 3;
+  DEBUG = 4;
+  VERBOSE = 5;
+  VERY_VERBOSE = 6;
+}
+
+message SubscribeLogsRequest {
+  LogLevel level = 1;
+  bool dump_config = 2;
+}
+
+message SubscribeLogsResponse {
+  LogLevel level = 1;
+  string tag = 2;
+  string message = 3;
+  bool send_failed = 4;
+}
+
+message SubscribeServiceCallsRequest {
+
+}
+
+message ServiceCallResponse {
+  string service = 1;
+  map<string, string> data = 2;
+  map<string, string> data_template = 3;
+  map<string, string> variables = 4;
+}
+
+// 1. Client sends SubscribeHomeAssistantStatesRequest
+// 2. Server responds with zero or more SubscribeHomeAssistantStateResponse (async)
+// 3. Client sends HomeAssistantStateResponse for state changes.
+message SubscribeHomeAssistantStatesRequest {
+
+}
+
+message SubscribeHomeAssistantStateResponse {
+  string entity_id = 1;
+}
+
+message HomeAssistantStateResponse {
+  string entity_id = 1;
+  string state = 2;
+}
+
+message GetTimeRequest {
+
+}
+
+message GetTimeResponse {
+  fixed32 epoch_seconds = 1;
+}
+

esphome/api/client.py

@@ -0,0 +1,495 @@
+from datetime import datetime
+import functools
+import logging
+import socket
+import threading
+import time
+
+# pylint: disable=unused-import
+from typing import Optional  # noqa
+from google.protobuf import message  # noqa
+
+from esphome import const
+import esphome.api.api_pb2 as pb
+from esphome.const import CONF_PASSWORD, CONF_PORT
+from esphome.core import EsphomeError
+from esphome.helpers import resolve_ip_address, indent, color
+from esphome.py_compat import text_type, IS_PY2, byte_to_bytes, char_to_byte, format_bytes
+from esphome.util import safe_print
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIConnectionError(EsphomeError):
+    pass
+
+
+MESSAGE_TYPE_TO_PROTO = {
+    1: pb.HelloRequest,
+    2: pb.HelloResponse,
+    3: pb.ConnectRequest,
+    4: pb.ConnectResponse,
+    5: pb.DisconnectRequest,
+    6: pb.DisconnectResponse,
+    7: pb.PingRequest,
+    8: pb.PingResponse,
+    9: pb.DeviceInfoRequest,
+    10: pb.DeviceInfoResponse,
+    11: pb.ListEntitiesRequest,
+    12: pb.ListEntitiesBinarySensorResponse,
+    13: pb.ListEntitiesCoverResponse,
+    14: pb.ListEntitiesFanResponse,
+    15: pb.ListEntitiesLightResponse,
+    16: pb.ListEntitiesSensorResponse,
+    17: pb.ListEntitiesSwitchResponse,
+    18: pb.ListEntitiesTextSensorResponse,
+    19: pb.ListEntitiesDoneResponse,
+    20: pb.SubscribeStatesRequest,
+    21: pb.BinarySensorStateResponse,
+    22: pb.CoverStateResponse,
+    23: pb.FanStateResponse,
+    24: pb.LightStateResponse,
+    25: pb.SensorStateResponse,
+    26: pb.SwitchStateResponse,
+    27: pb.TextSensorStateResponse,
+    28: pb.SubscribeLogsRequest,
+    29: pb.SubscribeLogsResponse,
+    30: pb.CoverCommandRequest,
+    31: pb.FanCommandRequest,
+    32: pb.LightCommandRequest,
+    33: pb.SwitchCommandRequest,
+    34: pb.SubscribeServiceCallsRequest,
+    35: pb.ServiceCallResponse,
+    36: pb.GetTimeRequest,
+    37: pb.GetTimeResponse,
+}
+
+
+def _varuint_to_bytes(value):
+    if value <= 0x7F:
+        return byte_to_bytes(value)
+
+    ret = bytes()
+    while value:
+        temp = value & 0x7F
+        value >>= 7
+        if value:
+            ret += byte_to_bytes(temp | 0x80)
+        else:
+            ret += byte_to_bytes(temp)
+
+    return ret
+
+
+def _bytes_to_varuint(value):
+    result = 0
+    bitpos = 0
+    for c in value:
+        val = char_to_byte(c)
+        result |= (val & 0x7F) << bitpos
+        bitpos += 7
+        if (val & 0x80) == 0:
+            return result
+    return None
+
+
+# pylint: disable=too-many-instance-attributes,not-callable
+class APIClient(threading.Thread):
+    def __init__(self, address, port, password):
+        threading.Thread.__init__(self)
+        self._address = address  # type: str
+        self._port = port  # type: int
+        self._password = password  # type: Optional[str]
+        self._socket = None  # type: Optional[socket.socket]
+        self._socket_open_event = threading.Event()
+        self._socket_write_lock = threading.Lock()
+        self._connected = False
+        self._authenticated = False
+        self._message_handlers = []
+        self._keepalive = 5
+        self._ping_timer = None
+        self._refresh_ping()
+
+        self.on_disconnect = None
+        self.on_connect = None
+        self.on_login = None
+        self.auto_reconnect = False
+        self._running_event = threading.Event()
+        self._stop_event = threading.Event()
+
+    @property
+    def stopped(self):
+        return self._stop_event.is_set()
+
+    def _refresh_ping(self):
+        if self._ping_timer is not None:
+            self._ping_timer.cancel()
+            self._ping_timer = None
+
+        def func():
+            self._ping_timer = None
+
+            if self._connected:
+                try:
+                    self.ping()
+                except APIConnectionError:
+                    self._fatal_error()
+                else:
+                    self._refresh_ping()
+
+        self._ping_timer = threading.Timer(self._keepalive, func)
+        self._ping_timer.start()
+
+    def _cancel_ping(self):
+        if self._ping_timer is not None:
+            self._ping_timer.cancel()
+            self._ping_timer = None
+
+    def _close_socket(self):
+        self._cancel_ping()
+        if self._socket is not None:
+            self._socket.close()
+            self._socket = None
+        self._socket_open_event.clear()
+        self._connected = False
+        self._authenticated = False
+        self._message_handlers = []
+
+    def stop(self, force=False):
+        if self.stopped:
+            raise ValueError
+
+        if self._connected and not force:
+            try:
+                self.disconnect()
+            except APIConnectionError:
+                pass
+        self._close_socket()
+
+        self._stop_event.set()
+        if not force:
+            self.join()
+
+    def connect(self):
+        if not self._running_event.wait(0.1):
+            raise APIConnectionError("You need to call start() first!")
+
+        if self._connected:
+            raise APIConnectionError("Already connected!")
+
+        try:
+            ip = resolve_ip_address(self._address)
+        except EsphomeError as err:
+            _LOGGER.warning("Error resolving IP address of %s. Is it connected to WiFi?",
+                            self._address)
+            _LOGGER.warning("(If this error persists, please set a static IP address: "
+                            "https://esphome.io/components/wifi.html#manual-ips)")
+            raise APIConnectionError(err)
+
+        _LOGGER.info("Connecting to %s:%s (%s)", self._address, self._port, ip)
+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._socket.settimeout(10.0)
+        self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        try:
+            self._socket.connect((ip, self._port))
+        except socket.error as err:
+            self._fatal_error()
+            raise APIConnectionError("Error connecting to {}: {}".format(ip, err))
+        self._socket.settimeout(0.1)
+
+        self._socket_open_event.set()
+
+        hello = pb.HelloRequest()
+        hello.client_info = 'ESPHome v{}'.format(const.__version__)
+        try:
+            resp = self._send_message_await_response(hello, pb.HelloResponse)
+        except APIConnectionError as err:
+            self._fatal_error()
+            raise err
+        _LOGGER.debug("Successfully connected to %s ('%s' API=%s.%s)", self._address,
+                      resp.server_info, resp.api_version_major, resp.api_version_minor)
+        self._connected = True
+        if self.on_connect is not None:
+            self.on_connect()
+
+    def _check_connected(self):
+        if not self._connected:
+            self._fatal_error()
+            raise APIConnectionError("Must be connected!")
+
+    def login(self):
+        self._check_connected()
+        if self._authenticated:
+            raise APIConnectionError("Already logged in!")
+
+        connect = pb.ConnectRequest()
+        if self._password is not None:
+            connect.password = self._password
+        resp = self._send_message_await_response(connect, pb.ConnectResponse)
+        if resp.invalid_password:
+            raise APIConnectionError("Invalid password!")
+
+        self._authenticated = True
+        if self.on_login is not None:
+            self.on_login()
+
+    def _fatal_error(self):
+        was_connected = self._connected
+
+        self._close_socket()
+
+        if was_connected and self.on_disconnect is not None:
+            self.on_disconnect()
+
+    def _write(self, data):  # type: (bytes) -> None
+        if self._socket is None:
+            raise APIConnectionError("Socket closed")
+
+        _LOGGER.debug("Write: %s", format_bytes(data))
+        with self._socket_write_lock:
+            try:
+                self._socket.sendall(data)
+            except socket.error as err:
+                self._fatal_error()
+                raise APIConnectionError("Error while writing data: {}".format(err))
+
+    def _send_message(self, msg):
+        # type: (message.Message) -> None
+        for message_type, klass in MESSAGE_TYPE_TO_PROTO.items():
+            if isinstance(msg, klass):
+                break
+        else:
+            raise ValueError
+
+        encoded = msg.SerializeToString()
+        _LOGGER.debug("Sending %s:\n%s", type(msg), indent(text_type(msg)))
+        if IS_PY2:
+            req = chr(0x00)
+        else:
+            req = bytes([0])
+        req += _varuint_to_bytes(len(encoded))
+        req += _varuint_to_bytes(message_type)
+        req += encoded
+        self._write(req)
+        self._refresh_ping()
+
+    def _send_message_await_response_complex(self, send_msg, do_append, do_stop, timeout=1):
+        event = threading.Event()
+        responses = []
+
+        def on_message(resp):
+            if do_append(resp):
+                responses.append(resp)
+            if do_stop(resp):
+                event.set()
+
+        self._message_handlers.append(on_message)
+        self._send_message(send_msg)
+        ret = event.wait(timeout)
+        try:
+            self._message_handlers.remove(on_message)
+        except ValueError:
+            pass
+        if not ret:
+            raise APIConnectionError("Timeout while waiting for message response!")
+        return responses
+
+    def _send_message_await_response(self, send_msg, response_type, timeout=1):
+        def is_response(msg):
+            return isinstance(msg, response_type)
+
+        return self._send_message_await_response_complex(send_msg, is_response, is_response,
+                                                         timeout)[0]
+
+    def device_info(self):
+        self._check_connected()
+        return self._send_message_await_response(pb.DeviceInfoRequest(), pb.DeviceInfoResponse)
+
+    def ping(self):
+        self._check_connected()
+        return self._send_message_await_response(pb.PingRequest(), pb.PingResponse)
+
+    def disconnect(self):
+        self._check_connected()
+
+        try:
+            self._send_message_await_response(pb.DisconnectRequest(), pb.DisconnectResponse)
+        except APIConnectionError:
+            pass
+        self._close_socket()
+
+        if self.on_disconnect is not None:
+            self.on_disconnect()
+
+    def _check_authenticated(self):
+        if not self._authenticated:
+            raise APIConnectionError("Must login first!")
+
+    def subscribe_logs(self, on_log, log_level=None, dump_config=False):
+        self._check_authenticated()
+
+        def on_msg(msg):
+            if isinstance(msg, pb.SubscribeLogsResponse):
+                on_log(msg)
+
+        self._message_handlers.append(on_msg)
+        req = pb.SubscribeLogsRequest(dump_config=dump_config)
+        if log_level is not None:
+            req.level = log_level
+        self._send_message(req)
+
+    def _recv(self, amount):
+        ret = bytes()
+        if amount == 0:
+            return ret
+
+        while len(ret) < amount:
+            if self.stopped:
+                raise APIConnectionError("Stopped!")
+            if not self._socket_open_event.is_set():
+                raise APIConnectionError("No socket!")
+            try:
+                val = self._socket.recv(amount - len(ret))
+            except AttributeError:
+                raise APIConnectionError("Socket was closed")
+            except socket.timeout:
+                continue
+            except socket.error as err:
+                raise APIConnectionError("Error while receiving data: {}".format(err))
+            ret += val
+        return ret
+
+    def _recv_varint(self):
+        raw = bytes()
+        while not raw or char_to_byte(raw[-1]) & 0x80:
+            raw += self._recv(1)
+        return _bytes_to_varuint(raw)
+
+    def _run_once(self):
+        if not self._socket_open_event.wait(0.1):
+            return
+
+        # Preamble
+        if char_to_byte(self._recv(1)[0]) != 0x00:
+            raise APIConnectionError("Invalid preamble")
+
+        length = self._recv_varint()
+        msg_type = self._recv_varint()
+
+        raw_msg = self._recv(length)
+        if msg_type not in MESSAGE_TYPE_TO_PROTO:
+            _LOGGER.debug("Skipping message type %s", msg_type)
+            return
+
+        msg = MESSAGE_TYPE_TO_PROTO[msg_type]()
+        msg.ParseFromString(raw_msg)
+        _LOGGER.debug("Got message: %s:\n%s", type(msg), indent(str(msg)))
+        for msg_handler in self._message_handlers[:]:
+            msg_handler(msg)
+        self._handle_internal_messages(msg)
+        self._refresh_ping()
+
+    def run(self):
+        self._running_event.set()
+        while not self.stopped:
+            try:
+                self._run_once()
+            except APIConnectionError as err:
+                if self.stopped:
+                    break
+                if self._connected:
+                    _LOGGER.error("Error while reading incoming messages: %s", err)
+                    self._fatal_error()
+        self._running_event.clear()
+
+    def _handle_internal_messages(self, msg):
+        if isinstance(msg, pb.DisconnectRequest):
+            self._send_message(pb.DisconnectResponse())
+            if self._socket is not None:
+                self._socket.close()
+                self._socket = None
+            self._connected = False
+            if self.on_disconnect is not None:
+                self.on_disconnect()
+        elif isinstance(msg, pb.PingRequest):
+            self._send_message(pb.PingResponse())
+        elif isinstance(msg, pb.GetTimeRequest):
+            resp = pb.GetTimeResponse()
+            resp.epoch_seconds = int(time.time())
+            self._send_message(resp)
+
+
+def run_logs(config, address):
+    conf = config['api']
+    port = conf[CONF_PORT]
+    password = conf[CONF_PASSWORD]
+    _LOGGER.info("Starting log output from %s using esphome API", address)
+
+    cli = APIClient(address, port, password)
+    stopping = False
+    retry_timer = []
+
+    has_connects = []
+
+    def try_connect(tries=0, is_disconnect=True):
+        if stopping:
+            return
+
+        if is_disconnect:
+            _LOGGER.warning(u"Disconnected from API.")
+
+        while retry_timer:
+            retry_timer.pop(0).cancel()
+
+        error = None
+        try:
+            cli.connect()
+            cli.login()
+        except APIConnectionError as err:  # noqa
+            error = err
+
+        if error is None:
+            _LOGGER.info("Successfully connected to %s", address)
+            return
+
+        wait_time = min(2**tries, 300)
+        if not has_connects:
+            _LOGGER.warning(u"Initial connection failed. The ESP might not be connected "
+                            u"to WiFi yet (%s). Re-Trying in %s seconds",
+                            error, wait_time)
+        else:
+            _LOGGER.warning(u"Couldn't connect to API (%s). Trying to reconnect in %s seconds",
+                            error, wait_time)
+        timer = threading.Timer(wait_time, functools.partial(try_connect, tries + 1, is_disconnect))
+        timer.start()
+        retry_timer.append(timer)
+
+    def on_log(msg):
+        time_ = datetime.now().time().strftime(u'[%H:%M:%S]')
+        text = msg.message
+        if msg.send_failed:
+            text = color('white', '(Message skipped because it was too big to fit in '
+                                  'TCP buffer - This is only cosmetic)')
+        safe_print(time_ + text)
+
+    def on_login():
+        try:
+            cli.subscribe_logs(on_log, dump_config=not has_connects)
+            has_connects.append(True)
+        except APIConnectionError:
+            cli.disconnect()
+
+    cli.on_disconnect = try_connect
+    cli.on_login = on_login
+    cli.start()
+
+    try:
+        try_connect(is_disconnect=False)
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        stopping = True
+        cli.stop(True)
+        while retry_timer:
+            retry_timer.pop(0).cancel()
+    return 0

esphome/automation.py

@@ -0,0 +1,384 @@
+import copy
+
+import voluptuous as vol
+
+import esphome.config_validation as cv
+from esphome.const import CONF_ABOVE, CONF_ACTION_ID, CONF_AND, CONF_AUTOMATION_ID, CONF_BELOW, \
+    CONF_CONDITION, CONF_CONDITION_ID, CONF_DELAY, CONF_ELSE, CONF_ID, CONF_IF, CONF_LAMBDA, \
+    CONF_OR, CONF_RANGE, CONF_THEN, CONF_TRIGGER_ID, CONF_WAIT_UNTIL, CONF_WHILE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, TemplateArguments, add, get_variable, \
+    process_lambda, templatable
+from esphome.cpp_types import Action, App, Component, PollingComponent, Trigger, bool_, \
+    esphome_ns, float_, uint32, void
+from esphome.util import ServiceRegistry
+
+
+def maybe_simple_id(*validators):
+    validator = vol.All(*validators)
+
+    def validate(value):
+        if isinstance(value, dict):
+            return validator(value)
+        return validator({CONF_ID: value})
+
+    return validate
+
+
+def validate_recursive_condition(value):
+    is_list = isinstance(value, list)
+    value = cv.ensure_list()(value)[:]
+    for i, item in enumerate(value):
+        path = [i] if is_list else []
+        item = copy.deepcopy(item)
+        if not isinstance(item, dict):
+            raise vol.Invalid(u"Condition must consist of key-value mapping! Got {}".format(item),
+                              path)
+        key = next((x for x in item if x != CONF_CONDITION_ID), None)
+        if key is None:
+            raise vol.Invalid(u"Key missing from action! Got {}".format(item), path)
+        if key not in CONDITION_REGISTRY:
+            raise vol.Invalid(u"Unable to find condition with the name '{}', is the "
+                              u"component loaded?".format(key), path + [key])
+        item.setdefault(CONF_CONDITION_ID, None)
+        key2 = next((x for x in item if x not in (CONF_CONDITION_ID, key)), None)
+        if key2 is not None:
+            raise vol.Invalid(u"Cannot have two conditions in one item. Key '{}' overrides '{}'! "
+                              u"Did you forget to indent the block inside the condition?"
+                              u"".format(key, key2), path)
+        validator = CONDITION_REGISTRY[key][0]
+        try:
+            condition = validator(item[key] or {})
+        except vol.Invalid as err:
+            err.prepend(path)
+            raise err
+        value[i] = {
+            CONF_CONDITION_ID: cv.declare_variable_id(Condition)(item[CONF_CONDITION_ID]),
+            key: condition,
+        }
+    return value
+
+
+def validate_recursive_action(value):
+    is_list = isinstance(value, list)
+    if not is_list:
+        value = [value]
+    for i, item in enumerate(value):
+        path = [i] if is_list else []
+        item = copy.deepcopy(item)
+        if not isinstance(item, dict):
+            raise vol.Invalid(u"Action must consist of key-value mapping! Got {}".format(item),
+                              path)
+        key = next((x for x in item if x != CONF_ACTION_ID), None)
+        if key is None:
+            raise vol.Invalid(u"Key missing from action! Got {}".format(item), path)
+        if key not in ACTION_REGISTRY:
+            raise vol.Invalid(u"Unable to find action with the name '{}', is the component loaded?"
+                              u"".format(key), path + [key])
+        item.setdefault(CONF_ACTION_ID, None)
+        key2 = next((x for x in item if x not in (CONF_ACTION_ID, key)), None)
+        if key2 is not None:
+            raise vol.Invalid(u"Cannot have two actions in one item. Key '{}' overrides '{}'! "
+                              u"Did you forget to indent the block inside the action?"
+                              u"".format(key, key2), path)
+        validator = ACTION_REGISTRY[key][0]
+        try:
+            action = validator(item[key] or {})
+        except vol.Invalid as err:
+            err.prepend(path)
+            raise err
+        value[i] = {
+            CONF_ACTION_ID: cv.declare_variable_id(Action)(item[CONF_ACTION_ID]),
+            key: action,
+        }
+    return value
+
+
+ACTION_REGISTRY = ServiceRegistry()
+CONDITION_REGISTRY = ServiceRegistry()
+
+# pylint: disable=invalid-name
+DelayAction = esphome_ns.class_('DelayAction', Action, Component)
+LambdaAction = esphome_ns.class_('LambdaAction', Action)
+IfAction = esphome_ns.class_('IfAction', Action)
+WhileAction = esphome_ns.class_('WhileAction', Action)
+WaitUntilAction = esphome_ns.class_('WaitUntilAction', Action, Component)
+UpdateComponentAction = esphome_ns.class_('UpdateComponentAction', Action)
+Automation = esphome_ns.class_('Automation')
+
+Condition = esphome_ns.class_('Condition')
+AndCondition = esphome_ns.class_('AndCondition', Condition)
+OrCondition = esphome_ns.class_('OrCondition', Condition)
+RangeCondition = esphome_ns.class_('RangeCondition', Condition)
+LambdaCondition = esphome_ns.class_('LambdaCondition', Condition)
+
+
+def validate_automation(extra_schema=None, extra_validators=None, single=False):
+    if extra_schema is None:
+        extra_schema = {}
+    if isinstance(extra_schema, vol.Schema):
+        extra_schema = extra_schema.schema
+    schema = AUTOMATION_SCHEMA.extend(extra_schema)
+
+    def validator_(value):
+        if isinstance(value, list):
+            try:
+                # First try as a sequence of actions
+                return [schema({CONF_THEN: value})]
+            except vol.Invalid as err:
+                if err.path and err.path[0] == CONF_THEN:
+                    err.path.pop(0)
+
+                # Next try as a sequence of automations
+                try:
+                    return cv.Schema([schema])(value)
+                except vol.Invalid as err2:
+                    if 'Unable to find action' in str(err):
+                        raise err2
+                    raise vol.MultipleInvalid([err, err2])
+        elif isinstance(value, dict):
+            if CONF_THEN in value:
+                return [schema(value)]
+            return [schema({CONF_THEN: value})]
+        # This should only happen with invalid configs, but let's have a nice error message.
+        return [schema(value)]
+
+    def validator(value):
+        value = validator_(value)
+        if extra_validators is not None:
+            value = cv.Schema([extra_validators])(value)
+        if single:
+            if len(value) != 1:
+                raise vol.Invalid("Cannot have more than 1 automation for templates")
+            return value[0]
+        return value
+
+    return validator
+
+
+AUTOMATION_SCHEMA = cv.Schema({
+    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(Trigger),
+    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(Automation),
+    vol.Required(CONF_THEN): validate_recursive_action,
+})
+
+AND_CONDITION_SCHEMA = validate_recursive_condition
+
+
+@CONDITION_REGISTRY.register(CONF_AND, AND_CONDITION_SCHEMA)
+def and_condition_to_code(config, condition_id, template_arg, args):
+    for conditions in build_conditions(config, template_arg, args):
+        yield
+    rhs = AndCondition.new(template_arg, conditions)
+    type = AndCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+OR_CONDITION_SCHEMA = validate_recursive_condition
+
+
+@CONDITION_REGISTRY.register(CONF_OR, OR_CONDITION_SCHEMA)
+def or_condition_to_code(config, condition_id, template_arg, args):
+    for conditions in build_conditions(config, template_arg, args):
+        yield
+    rhs = OrCondition.new(template_arg, conditions)
+    type = OrCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+RANGE_CONDITION_SCHEMA = vol.All(cv.Schema({
+    vol.Optional(CONF_ABOVE): cv.templatable(cv.float_),
+    vol.Optional(CONF_BELOW): cv.templatable(cv.float_),
+}), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
+
+
+@CONDITION_REGISTRY.register(CONF_RANGE, RANGE_CONDITION_SCHEMA)
+def range_condition_to_code(config, condition_id, template_arg, args):
+    for conditions in build_conditions(config, template_arg, args):
+        yield
+    rhs = RangeCondition.new(template_arg, conditions)
+    type = RangeCondition.template(template_arg)
+    condition = Pvariable(condition_id, rhs, type=type)
+    if CONF_ABOVE in config:
+        for template_ in templatable(config[CONF_ABOVE], args, float_):
+            yield
+        condition.set_min(template_)
+    if CONF_BELOW in config:
+        for template_ in templatable(config[CONF_BELOW], args, float_):
+            yield
+        condition.set_max(template_)
+    yield condition
+
+
+DELAY_ACTION_SCHEMA = cv.templatable(cv.positive_time_period_milliseconds)
+
+
+@ACTION_REGISTRY.register(CONF_DELAY, DELAY_ACTION_SCHEMA)
+def delay_action_to_code(config, action_id, template_arg, args):
+    rhs = App.register_component(DelayAction.new(template_arg))
+    type = DelayAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config, args, uint32):
+        yield
+    add(action.set_delay(template_))
+    yield action
+
+
+IF_ACTION_SCHEMA = vol.All({
+    vol.Required(CONF_CONDITION): validate_recursive_condition,
+    vol.Optional(CONF_THEN): validate_recursive_action,
+    vol.Optional(CONF_ELSE): validate_recursive_action,
+}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE))
+
+
+@ACTION_REGISTRY.register(CONF_IF, IF_ACTION_SCHEMA)
+def if_action_to_code(config, action_id, template_arg, args):
+    for conditions in build_conditions(config[CONF_CONDITION], template_arg, args):
+        yield None
+    rhs = IfAction.new(template_arg, conditions)
+    type = IfAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_THEN in config:
+        for actions in build_actions(config[CONF_THEN], template_arg, args):
+            yield None
+        add(action.add_then(actions))
+    if CONF_ELSE in config:
+        for actions in build_actions(config[CONF_ELSE], template_arg, args):
+            yield None
+        add(action.add_else(actions))
+    yield action
+
+
+WHILE_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_CONDITION): validate_recursive_condition,
+    vol.Required(CONF_THEN): validate_recursive_action,
+})
+
+
+@ACTION_REGISTRY.register(CONF_WHILE, WHILE_ACTION_SCHEMA)
+def while_action_to_code(config, action_id, template_arg, args):
+    for conditions in build_conditions(config[CONF_CONDITION], template_arg, args):
+        yield None
+    rhs = WhileAction.new(template_arg, conditions)
+    type = WhileAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for actions in build_actions(config[CONF_THEN], template_arg, args):
+        yield None
+    add(action.add_then(actions))
+    yield action
+
+
+def validate_wait_until(value):
+    schema = cv.Schema({
+        vol.Required(CONF_CONDITION): validate_recursive_condition
+    })
+    if isinstance(value, dict) and CONF_CONDITION in value:
+        return schema(value)
+    return validate_wait_until({CONF_CONDITION: value})
+
+
+WAIT_UNTIL_ACTION_SCHEMA = validate_wait_until
+
+
+@ACTION_REGISTRY.register(CONF_WAIT_UNTIL, WAIT_UNTIL_ACTION_SCHEMA)
+def wait_until_action_to_code(config, action_id, template_arg, args):
+    for conditions in build_conditions(config[CONF_CONDITION], template_arg, args):
+        yield None
+    rhs = WaitUntilAction.new(template_arg, conditions)
+    type = WaitUntilAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    add(App.register_component(action))
+    yield action
+
+
+LAMBDA_ACTION_SCHEMA = cv.lambda_
+
+
+@ACTION_REGISTRY.register(CONF_LAMBDA, LAMBDA_ACTION_SCHEMA)
+def lambda_action_to_code(config, action_id, template_arg, args):
+    for lambda_ in process_lambda(config, args, return_type=void):
+        yield None
+    rhs = LambdaAction.new(template_arg, lambda_)
+    type = LambdaAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+LAMBDA_CONDITION_SCHEMA = cv.lambda_
+
+
+@CONDITION_REGISTRY.register(CONF_LAMBDA, LAMBDA_CONDITION_SCHEMA)
+def lambda_condition_to_code(config, condition_id, template_arg, args):
+    for lambda_ in process_lambda(config, args, return_type=bool_):
+        yield
+    rhs = LambdaCondition.new(template_arg, lambda_)
+    type = LambdaCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+CONF_COMPONENT_UPDATE = 'component.update'
+COMPONENT_UPDATE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(PollingComponent),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COMPONENT_UPDATE, COMPONENT_UPDATE_ACTION_SCHEMA)
+def component_update_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = UpdateComponentAction.new(template_arg, var)
+    type = UpdateComponentAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+def build_action(full_config, template_arg, args):
+    action_id = full_config[CONF_ACTION_ID]
+    key, config = next((k, v) for k, v in full_config.items() if k in ACTION_REGISTRY)
+
+    builder = ACTION_REGISTRY[key][1]
+    for result in builder(config, action_id, template_arg, args):
+        yield None
+    yield result
+
+
+def build_actions(config, templ, arg_type):
+    actions = []
+    for conf in config:
+        for action in build_action(conf, templ, arg_type):
+            yield None
+        actions.append(action)
+    yield actions
+
+
+def build_condition(full_config, template_arg, args):
+    action_id = full_config[CONF_CONDITION_ID]
+    key, config = next((k, v) for k, v in full_config.items() if k in CONDITION_REGISTRY)
+
+    builder = CONDITION_REGISTRY[key][1]
+    for result in builder(config, action_id, template_arg, args):
+        yield None
+    yield result
+
+
+def build_conditions(config, templ, args):
+    conditions = []
+    for conf in config:
+        for condition in build_condition(conf, templ, args):
+            yield None
+        conditions.append(condition)
+    yield conditions
+
+
+def build_automation_(trigger, args, config):
+    arg_types = [arg[0] for arg in args]
+    templ = TemplateArguments(*arg_types)
+    rhs = App.make_automation(templ, trigger)
+    type = Automation.template(templ)
+    obj = Pvariable(config[CONF_AUTOMATION_ID], rhs, type=type)
+    for actions in build_actions(config[CONF_THEN], templ, args):
+        yield None
+    add(obj.add_actions(actions))
+    yield obj
+
+
+def build_automations(trigger, args, config):
+    CORE.add_job(build_automation_, trigger, args, config)

esphome/components/ads1115.py

@@ -0,0 +1,27 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+ADS1115Component = sensor.sensor_ns.class_('ADS1115Component', Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ADS1115Component),
+    vol.Required(CONF_ADDRESS): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_ads1115_component(config[CONF_ADDRESS])
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphome/components/apds9960.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+CONF_APDS9960_ID = 'apds9960_id'
+APDS9960 = sensor.sensor_ns.class_('APDS9960', PollingComponent, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(APDS9960),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_apds9960(config.get(CONF_UPDATE_INTERVAL))
+    var = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_ADDRESS in config:
+        add(var.set_address(config[CONF_ADDRESS]))
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_APDS9960'

esphome/components/api.py

@@ -0,0 +1,141 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA, CONF_DATA_TEMPLATE, CONF_ID, CONF_PASSWORD, CONF_PORT, \
+    CONF_REBOOT_TIMEOUT, CONF_SERVICE, CONF_VARIABLES, CONF_SERVICES, CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, Component, StoringController, esphome_ns, Trigger, \
+    bool_, int32, float_, std_string
+
+api_ns = esphome_ns.namespace('api')
+APIServer = api_ns.class_('APIServer', Component, StoringController)
+HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', Action)
+KeyValuePair = api_ns.class_('KeyValuePair')
+TemplatableKeyValuePair = api_ns.class_('TemplatableKeyValuePair')
+APIConnectedCondition = api_ns.class_('APIConnectedCondition', Condition)
+
+UserService = api_ns.class_('UserService', Trigger)
+ServiceTypeArgument = api_ns.class_('ServiceTypeArgument')
+ServiceArgType = api_ns.enum('ServiceArgType')
+SERVICE_ARG_TYPES = {
+    'bool': ServiceArgType.SERVICE_ARG_TYPE_BOOL,
+    'int': ServiceArgType.SERVICE_ARG_TYPE_INT,
+    'float': ServiceArgType.SERVICE_ARG_TYPE_FLOAT,
+    'string': ServiceArgType.SERVICE_ARG_TYPE_STRING,
+}
+SERVICE_ARG_NATIVE_TYPES = {
+    'bool': bool_,
+    'int': int32,
+    'float': float_,
+    'string': std_string,
+}
+
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(APIServer),
+    vol.Optional(CONF_PORT, default=6053): cv.port,
+    vol.Optional(CONF_PASSWORD, default=''): cv.string_strict,
+    vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_SERVICES): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(UserService),
+        vol.Required(CONF_SERVICE): cv.valid_name,
+        vol.Optional(CONF_VARIABLES, default={}): cv.Schema({
+            cv.validate_id_name: cv.one_of(*SERVICE_ARG_TYPES, lower=True),
+        }),
+    }),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.init_api_server()
+    api = Pvariable(config[CONF_ID], rhs)
+
+    if config[CONF_PORT] != 6053:
+        add(api.set_port(config[CONF_PORT]))
+    if config.get(CONF_PASSWORD):
+        add(api.set_password(config[CONF_PASSWORD]))
+    if CONF_REBOOT_TIMEOUT in config:
+        add(api.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+
+    for conf in config.get(CONF_SERVICES, []):
+        template_args = []
+        func_args = []
+        service_type_args = []
+        for name, var_ in conf[CONF_VARIABLES].items():
+            native = SERVICE_ARG_NATIVE_TYPES[var_]
+            template_args.append(native)
+            func_args.append((native, name))
+            service_type_args.append(ServiceTypeArgument(name, SERVICE_ARG_TYPES[var_]))
+        func = api.make_user_service_trigger.template(*template_args)
+        rhs = func(conf[CONF_SERVICE], service_type_args)
+        type_ = UserService.template(*template_args)
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs, type=type_)
+        automation.build_automations(trigger, func_args, conf)
+
+    setup_component(api, config)
+
+
+BUILD_FLAGS = '-DUSE_API'
+
+
+def lib_deps(config):
+    if CORE.is_esp32:
+        return 'AsyncTCP@1.0.3'
+    if CORE.is_esp8266:
+        return 'ESPAsyncTCP@1.1.3'
+    raise NotImplementedError
+
+
+CONF_HOMEASSISTANT_SERVICE = 'homeassistant.service'
+HOMEASSISTANT_SERVIC_ACTION_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_variable_id(APIServer),
+    vol.Required(CONF_SERVICE): cv.string,
+    vol.Optional(CONF_DATA): cv.Schema({
+        cv.string: cv.string,
+    }),
+    vol.Optional(CONF_DATA_TEMPLATE): cv.Schema({
+        cv.string: cv.string,
+    }),
+    vol.Optional(CONF_VARIABLES): cv.Schema({
+        cv.string: cv.lambda_,
+    }),
+})
+
+
+@ACTION_REGISTRY.register(CONF_HOMEASSISTANT_SERVICE, HOMEASSISTANT_SERVIC_ACTION_SCHEMA)
+def homeassistant_service_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_home_assistant_service_call_action(template_arg)
+    type = HomeAssistantServiceCallAction.template(template_arg)
+    act = Pvariable(action_id, rhs, type=type)
+    add(act.set_service(config[CONF_SERVICE]))
+    if CONF_DATA in config:
+        datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA].items()]
+        add(act.set_data(datas))
+    if CONF_DATA_TEMPLATE in config:
+        datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA_TEMPLATE].items()]
+        add(act.set_data_template(datas))
+    if CONF_VARIABLES in config:
+        datas = []
+        for key, value in config[CONF_VARIABLES].items():
+            for value_ in process_lambda(value, []):
+                yield None
+            datas.append(TemplatableKeyValuePair(key, value_))
+        add(act.set_variables(datas))
+    yield act
+
+
+CONF_API_CONNECTED = 'api.connected'
+API_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
+
+
+@CONDITION_REGISTRY.register(CONF_API_CONNECTED, API_CONNECTED_CONDITION_SCHEMA)
+def api_connected_to_code(config, condition_id, template_arg, args):
+    rhs = APIConnectedCondition.new(template_arg)
+    type = APIConnectedCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/binary_sensor/__init__.py

@@ -0,0 +1,321 @@
+import voluptuous as vol
+
+from esphome import automation, core
+from esphome.automation import CONDITION_REGISTRY, Condition, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_DELAYED_OFF, CONF_DELAYED_ON, CONF_DEVICE_CLASS, CONF_FILTERS, \
+    CONF_HEARTBEAT, CONF_ID, CONF_INTERNAL, CONF_INVALID_COOLDOWN, CONF_INVERT, CONF_INVERTED, \
+    CONF_LAMBDA, CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_MQTT_ID, CONF_ON_CLICK, \
+    CONF_ON_DOUBLE_CLICK, CONF_ON_MULTI_CLICK, CONF_ON_PRESS, CONF_ON_RELEASE, CONF_ON_STATE, \
+    CONF_STATE, CONF_TIMING, CONF_TRIGGER_ID, CONF_FOR
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, StructInitializer, add, get_variable, process_lambda
+from esphome.cpp_types import App, Component, Nameable, Trigger, bool_, esphome_ns, optional
+from esphome.py_compat import string_types
+
+DEVICE_CLASSES = [
+    '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
+    'heat', 'light', 'lock', 'moisture', 'motion', 'moving', 'occupancy',
+    'opening', 'plug', 'power', 'presence', 'problem', 'safety', 'smoke',
+    'sound', 'vibration', 'window'
+]
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+binary_sensor_ns = esphome_ns.namespace('binary_sensor')
+BinarySensor = binary_sensor_ns.class_('BinarySensor', Nameable)
+BinarySensorPtr = BinarySensor.operator('ptr')
+MQTTBinarySensorComponent = binary_sensor_ns.class_('MQTTBinarySensorComponent', mqtt.MQTTComponent)
+
+# Triggers
+PressTrigger = binary_sensor_ns.class_('PressTrigger', Trigger.template())
+ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', Trigger.template())
+ClickTrigger = binary_sensor_ns.class_('ClickTrigger', Trigger.template())
+DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', Trigger.template())
+MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', Trigger.template(), Component)
+MultiClickTriggerEvent = binary_sensor_ns.struct('MultiClickTriggerEvent')
+StateTrigger = binary_sensor_ns.class_('StateTrigger', Trigger.template(bool_))
+
+# Condition
+BinarySensorCondition = binary_sensor_ns.class_('BinarySensorCondition', Condition)
+
+# Filters
+Filter = binary_sensor_ns.class_('Filter')
+DelayedOnFilter = binary_sensor_ns.class_('DelayedOnFilter', Filter, Component)
+DelayedOffFilter = binary_sensor_ns.class_('DelayedOffFilter', Filter, Component)
+HeartbeatFilter = binary_sensor_ns.class_('HeartbeatFilter', Filter, Component)
+InvertFilter = binary_sensor_ns.class_('InvertFilter', Filter)
+LambdaFilter = binary_sensor_ns.class_('LambdaFilter', Filter)
+
+FILTER_KEYS = [CONF_INVERT, CONF_DELAYED_ON, CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT]
+
+FILTERS_SCHEMA = cv.ensure_list({
+    vol.Optional(CONF_INVERT): None,
+    vol.Optional(CONF_DELAYED_ON): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DELAYED_OFF): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+
+    vol.Optional(CONF_HEARTBEAT): cv.invalid("The heartbeat filter has been removed in 1.11.0"),
+}, cv.has_exactly_one_key(*FILTER_KEYS))
+
+MULTI_CLICK_TIMING_SCHEMA = cv.Schema({
+    vol.Optional(CONF_STATE): cv.boolean,
+    vol.Optional(CONF_MIN_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_MAX_LENGTH): cv.positive_time_period_milliseconds,
+})
+
+
+def parse_multi_click_timing_str(value):
+    if not isinstance(value, string_types):
+        return value
+
+    parts = value.lower().split(' ')
+    if len(parts) != 5:
+        raise vol.Invalid("Multi click timing grammar consists of exactly 5 words, not {}"
+                          "".format(len(parts)))
+    try:
+        state = cv.boolean(parts[0])
+    except vol.Invalid:
+        raise vol.Invalid(u"First word must either be ON or OFF, not {}".format(parts[0]))
+
+    if parts[1] != 'for':
+        raise vol.Invalid(u"Second word must be 'for', got {}".format(parts[1]))
+
+    if parts[2] == 'at':
+        if parts[3] == 'least':
+            key = CONF_MIN_LENGTH
+        elif parts[3] == 'most':
+            key = CONF_MAX_LENGTH
+        else:
+            raise vol.Invalid(u"Third word after at must either be 'least' or 'most', got {}"
+                              u"".format(parts[3]))
+        try:
+            length = cv.positive_time_period_milliseconds(parts[4])
+        except vol.Invalid as err:
+            raise vol.Invalid(u"Multi Click Grammar Parsing length failed: {}".format(err))
+        return {
+            CONF_STATE: state,
+            key: str(length)
+        }
+
+    if parts[3] != 'to':
+        raise vol.Invalid("Multi click grammar: 4th word must be 'to'")
+
+    try:
+        min_length = cv.positive_time_period_milliseconds(parts[2])
+    except vol.Invalid as err:
+        raise vol.Invalid(u"Multi Click Grammar Parsing minimum length failed: {}".format(err))
+
+    try:
+        max_length = cv.positive_time_period_milliseconds(parts[4])
+    except vol.Invalid as err:
+        raise vol.Invalid(u"Multi Click Grammar Parsing minimum length failed: {}".format(err))
+
+    return {
+        CONF_STATE: state,
+        CONF_MIN_LENGTH: str(min_length),
+        CONF_MAX_LENGTH: str(max_length)
+    }
+
+
+def validate_multi_click_timing(value):
+    if not isinstance(value, list):
+        raise vol.Invalid("Timing option must be a *list* of times!")
+    timings = []
+    state = None
+    for i, v_ in enumerate(value):
+        v_ = MULTI_CLICK_TIMING_SCHEMA(v_)
+        min_length = v_.get(CONF_MIN_LENGTH)
+        max_length = v_.get(CONF_MAX_LENGTH)
+        if min_length is None and max_length is None:
+            raise vol.Invalid("At least one of min_length and max_length is required!")
+        if min_length is None and max_length is not None:
+            min_length = core.TimePeriodMilliseconds(milliseconds=0)
+
+        new_state = v_.get(CONF_STATE, not state)
+        if new_state == state:
+            raise vol.Invalid("Timings must have alternating state. Indices {} and {} have "
+                              "the same state {}".format(i, i + 1, state))
+        if max_length is not None and max_length < min_length:
+            raise vol.Invalid("Max length ({}) must be larger than min length ({})."
+                              "".format(max_length, min_length))
+
+        state = new_state
+        tim = {
+            CONF_STATE: new_state,
+            CONF_MIN_LENGTH: min_length,
+        }
+        if max_length is not None:
+            tim[CONF_MAX_LENGTH] = max_length
+        timings.append(tim)
+    return timings
+
+
+BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTBinarySensorComponent),
+
+    vol.Optional(CONF_DEVICE_CLASS): cv.one_of(*DEVICE_CLASSES, lower=True),
+    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
+    vol.Optional(CONF_ON_PRESS): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(PressTrigger),
+    }),
+    vol.Optional(CONF_ON_RELEASE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ReleaseTrigger),
+    }),
+    vol.Optional(CONF_ON_CLICK): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ClickTrigger),
+        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): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(DoubleClickTrigger),
+        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_MULTI_CLICK): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MultiClickTrigger),
+        vol.Required(CONF_TIMING): vol.All([parse_multi_click_timing_str],
+                                           validate_multi_click_timing),
+        vol.Optional(CONF_INVALID_COOLDOWN): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_ON_STATE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StateTrigger),
+    }),
+
+    vol.Optional(CONF_INVERTED): cv.invalid(
+        "The inverted binary_sensor property has been replaced by the "
+        "new 'invert' binary  sensor filter. Please see "
+        "https://esphome.io/components/binary_sensor/index.html."
+    ),
+})
+
+BINARY_SENSOR_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(BINARY_SENSOR_SCHEMA.schema)
+
+
+def setup_filter(config):
+    if CONF_INVERT in config:
+        yield InvertFilter.new()
+    elif CONF_DELAYED_OFF in config:
+        yield App.register_component(DelayedOffFilter.new(config[CONF_DELAYED_OFF]))
+    elif CONF_DELAYED_ON in config:
+        yield App.register_component(DelayedOnFilter.new(config[CONF_DELAYED_ON]))
+    elif CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(bool_, 'x')],
+                                      return_type=optional.template(bool_)):
+            yield None
+        yield LambdaFilter.new(lambda_)
+
+
+def setup_filters(config):
+    filters = []
+    for conf in config:
+        for filter in setup_filter(conf):
+            yield None
+        filters.append(filter)
+    yield filters
+
+
+def setup_binary_sensor_core_(binary_sensor_var, config):
+    if CONF_INTERNAL in config:
+        add(binary_sensor_var.set_internal(CONF_INTERNAL))
+    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]))
+    if CONF_FILTERS in config:
+        for filters in setup_filters(config[CONF_FILTERS]):
+            yield
+        add(binary_sensor_var.add_filters(filters))
+
+    for conf in config.get(CONF_ON_PRESS, []):
+        rhs = binary_sensor_var.make_press_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_RELEASE, []):
+        rhs = binary_sensor_var.make_release_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], 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(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], 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(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_MULTI_CLICK, []):
+        timings = []
+        for tim in conf[CONF_TIMING]:
+            timings.append(StructInitializer(
+                MultiClickTriggerEvent,
+                ('state', tim[CONF_STATE]),
+                ('min_length', tim[CONF_MIN_LENGTH]),
+                ('max_length', tim.get(CONF_MAX_LENGTH, 4294967294)),
+            ))
+        rhs = App.register_component(binary_sensor_var.make_multi_click_trigger(timings))
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        if CONF_INVALID_COOLDOWN in conf:
+            add(trigger.set_invalid_cooldown(conf[CONF_INVALID_COOLDOWN]))
+        automation.build_automations(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_STATE, []):
+        rhs = binary_sensor_var.make_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(bool_, 'x')], conf)
+
+    setup_mqtt_component(binary_sensor_var.Pget_mqtt(), config)
+
+
+def setup_binary_sensor(binary_sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        binary_sensor_obj = Pvariable(config[CONF_ID], binary_sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_binary_sensor_core_, binary_sensor_obj, config)
+
+
+def register_binary_sensor(var, config):
+    binary_sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_binary_sensor(binary_sensor_var))
+    CORE.add_job(setup_binary_sensor_core_, binary_sensor_var, config)
+
+
+BUILD_FLAGS = '-DUSE_BINARY_SENSOR'
+
+CONF_BINARY_SENSOR_IS_ON = 'binary_sensor.is_on'
+BINARY_SENSOR_IS_ON_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(BinarySensor),
+    vol.Optional(CONF_FOR): cv.positive_time_period_milliseconds,
+})
+
+
+@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_ON, BINARY_SENSOR_IS_ON_CONDITION_SCHEMA)
+def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_binary_sensor_is_on_condition(template_arg, config.get(CONF_FOR))
+    type = BinarySensorCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+CONF_BINARY_SENSOR_IS_OFF = 'binary_sensor.is_off'
+BINARY_SENSOR_IS_OFF_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(BinarySensor),
+    vol.Optional(CONF_FOR): cv.positive_time_period_milliseconds,
+})
+
+
+@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_OFF, BINARY_SENSOR_IS_OFF_CONDITION_SCHEMA)
+def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_binary_sensor_is_off_condition(template_arg, config.get(CONF_FOR))
+    type = BinarySensorCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/binary_sensor/apds9960.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor, sensor
+from esphome.components.apds9960 import APDS9960, CONF_APDS9960_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_DIRECTION, CONF_NAME
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['apds9960']
+APDS9960GestureDirectionBinarySensor = sensor.sensor_ns.class_(
+    'APDS9960GestureDirectionBinarySensor', binary_sensor.BinarySensor)
+
+DIRECTIONS = {
+    'UP': 'make_up_direction',
+    'DOWN': 'make_down_direction',
+    'LEFT': 'make_left_direction',
+    'RIGHT': 'make_right_direction',
+}
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(APDS9960GestureDirectionBinarySensor),
+    vol.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
+    cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_APDS9960_ID]):
+        yield
+    func = getattr(hub, DIRECTIONS[config[CONF_DIRECTION]])
+    rhs = func(config[CONF_NAME])
+    binary_sensor.register_binary_sensor(rhs, config)

esphome/components/binary_sensor/custom.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA, CONF_NAME
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomBinarySensorConstructor = binary_sensor.binary_sensor_ns.class_(
+    'CustomBinarySensorConstructor')
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomBinarySensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_BINARY_SENSORS):
+        cv.ensure_list(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(binary_sensor.BinarySensor),
+        })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(binary_sensor.BinarySensorPtr)):
+        yield
+
+    rhs = CustomBinarySensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_BINARY_SENSORS]):
+        rhs = custom.Pget_binary_sensor(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        binary_sensor.register_binary_sensor(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_BINARY_SENSOR'

esphome/components/binary_sensor/esp32_ble_tracker.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import esphome_ns
+
+DEPENDENCIES = ['esp32_ble_tracker']
+ESP32BLEPresenceDevice = esphome_ns.class_('ESP32BLEPresenceDevice', binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLEPresenceDevice),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_presence_sensor(config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
+    binary_sensor.register_binary_sensor(rhs, config)

esphome/components/binary_sensor/esp32_touch.py

@@ -0,0 +1,58 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+from esphome.components.esp32_touch import ESP32TouchComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_PIN, CONF_THRESHOLD, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import global_ns
+from esphome.pins import validate_gpio_pin
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+DEPENDENCIES = ['esp32_touch']
+
+CONF_ESP32_TOUCH_ID = 'esp32_touch_id'
+
+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
+
+
+ESP32TouchBinarySensor = binary_sensor.binary_sensor_ns.class_('ESP32TouchBinarySensor',
+                                                               binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ESP32TouchBinarySensor),
+    vol.Required(CONF_PIN): validate_touch_pad,
+    vol.Required(CONF_THRESHOLD): cv.uint16_t,
+    cv.GenerateID(CONF_ESP32_TOUCH_ID): cv.use_variable_id(ESP32TouchComponent),
+}))
+
+
+def to_code(config):
+    hub = None
+    for hub in get_variable(config[CONF_ESP32_TOUCH_ID]):
+        yield
+    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'

esphome/components/binary_sensor/gpio.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_PIN
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+GPIOBinarySensorComponent = binary_sensor.binary_sensor_ns.class_('GPIOBinarySensorComponent',
+                                                                  binary_sensor.BinarySensor,
+                                                                  Component)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(GPIOBinarySensorComponent),
+    vol.Required(CONF_PIN): pins.gpio_input_pin_schema
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    pin = None
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_gpio_binary_sensor(config[CONF_NAME], pin)
+    gpio = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_BINARY_SENSOR'

esphome/components/binary_sensor/homeassistant.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeassistantBinarySensor = binary_sensor.binary_sensor_ns.class_('HomeassistantBinarySensor',
+                                                                  binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantBinarySensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_binary_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    subs = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_BINARY_SENSOR'

esphome/components/binary_sensor/mpr121.py

@@ -0,0 +1,24 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+from esphome.components.mpr121 import MPR121Component, CONF_MPR121_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_NAME
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['mpr121']
+MPR121Channel = binary_sensor.binary_sensor_ns.class_(
+    'MPR121Channel', binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MPR121Channel),
+    cv.GenerateID(CONF_MPR121_ID): cv.use_variable_id(MPR121Component),
+    vol.Required(CONF_CHANNEL): vol.All(vol.Coerce(int), vol.Range(min=0, max=11))
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_MPR121_ID]):
+        yield
+    rhs = MPR121Channel.new(config[CONF_NAME], config[CONF_CHANNEL])
+    binary_sensor.register_binary_sensor(hub.add_channel(rhs), config)

esphome/components/binary_sensor/nextion.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor, display
+from esphome.components.display.nextion import Nextion
+import esphome.config_validation as cv
+from esphome.const import CONF_COMPONENT_ID, CONF_NAME, CONF_PAGE_ID
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['display']
+
+CONF_NEXTION_ID = 'nextion_id'
+
+NextionTouchComponent = display.display_ns.class_('NextionTouchComponent',
+                                                  binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(NextionTouchComponent),
+    vol.Required(CONF_PAGE_ID): cv.uint8_t,
+    vol.Required(CONF_COMPONENT_ID): cv.uint8_t,
+    cv.GenerateID(CONF_NEXTION_ID): cv.use_variable_id(Nextion)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_NEXTION_ID]):
+        yield
+    rhs = hub.make_touch_component(config[CONF_NAME], config[CONF_PAGE_ID],
+                                   config[CONF_COMPONENT_ID])
+    binary_sensor.register_binary_sensor(rhs, config)

esphome/components/binary_sensor/pn532.py

@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+from esphome.components.pn532 import PN532Component
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_UID
+from esphome.core import HexInt
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['pn532']
+
+CONF_PN532_ID = 'pn532_id'
+
+
+def validate_uid(value):
+    value = cv.string_strict(value)
+    for x in value.split('-'):
+        if len(x) != 2:
+            raise vol.Invalid("Each part (separated by '-') of the UID must be two characters "
+                              "long.")
+        try:
+            x = int(x, 16)
+        except ValueError:
+            raise vol.Invalid("Valid characters for parts of a UID are 0123456789ABCDEF.")
+        if x < 0 or x > 255:
+            raise vol.Invalid("Valid values for UID parts (separated by '-') are 00 to FF")
+    return value
+
+
+PN532BinarySensor = binary_sensor.binary_sensor_ns.class_('PN532BinarySensor',
+                                                          binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PN532BinarySensor),
+    vol.Required(CONF_UID): validate_uid,
+    cv.GenerateID(CONF_PN532_ID): cv.use_variable_id(PN532Component)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_PN532_ID]):
+        yield
+    addr = [HexInt(int(x, 16)) for x in config[CONF_UID].split('-')]
+    rhs = hub.make_tag(config[CONF_NAME], addr)
+    binary_sensor.register_binary_sensor(rhs, config)

esphome/components/binary_sensor/rdm6300.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor, rdm6300
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_UID
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['rdm6300']
+
+CONF_RDM6300_ID = 'rdm6300_id'
+
+RDM6300BinarySensor = binary_sensor.binary_sensor_ns.class_('RDM6300BinarySensor',
+                                                            binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RDM6300BinarySensor),
+    vol.Required(CONF_UID): cv.uint32_t,
+    cv.GenerateID(CONF_RDM6300_ID): cv.use_variable_id(rdm6300.RDM6300Component)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_RDM6300_ID]):
+        yield
+    rhs = hub.make_card(config[CONF_NAME], config[CONF_UID])
+    binary_sensor.register_binary_sensor(rhs, config)

esphome/components/binary_sensor/remote_receiver.py

@@ -0,0 +1,147 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+from esphome.components.remote_receiver import RemoteReceiverComponent, remote_ns
+from esphome.components.remote_transmitter import RC_SWITCH_RAW_SCHEMA, \
+    RC_SWITCH_TYPE_A_SCHEMA, RC_SWITCH_TYPE_B_SCHEMA, RC_SWITCH_TYPE_C_SCHEMA, \
+    RC_SWITCH_TYPE_D_SCHEMA, binary_code, build_rc_switch_protocol
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_CHANNEL, CONF_CODE, CONF_COMMAND, CONF_DATA, \
+    CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_ID, CONF_JVC, CONF_LG, CONF_NAME, CONF_NBITS, \
+    CONF_NEC, CONF_PANASONIC, CONF_PROTOCOL, CONF_RAW, CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, \
+    CONF_RC_SWITCH_TYPE_B, CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, CONF_SAMSUNG, CONF_SONY, \
+    CONF_STATE, CONF_RC5
+from esphome.cpp_generator import Pvariable, get_variable, progmem_array
+from esphome.cpp_types import int32
+
+DEPENDENCIES = ['remote_receiver']
+
+REMOTE_KEYS = [CONF_JVC, CONF_NEC, CONF_LG, CONF_SONY, CONF_PANASONIC, CONF_SAMSUNG, CONF_RAW,
+               CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B,
+               CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, CONF_RC5]
+
+CONF_REMOTE_RECEIVER_ID = 'remote_receiver_id'
+CONF_RECEIVER_ID = 'receiver_id'
+
+RemoteReceiver = remote_ns.class_('RemoteReceiver', binary_sensor.BinarySensor)
+JVCReceiver = remote_ns.class_('JVCReceiver', RemoteReceiver)
+LGReceiver = remote_ns.class_('LGReceiver', RemoteReceiver)
+NECReceiver = remote_ns.class_('NECReceiver', RemoteReceiver)
+PanasonicReceiver = remote_ns.class_('PanasonicReceiver', RemoteReceiver)
+RawReceiver = remote_ns.class_('RawReceiver', RemoteReceiver)
+SamsungReceiver = remote_ns.class_('SamsungReceiver', RemoteReceiver)
+SonyReceiver = remote_ns.class_('SonyReceiver', RemoteReceiver)
+RC5Receiver = remote_ns.class_('RC5Receiver', RemoteReceiver)
+RCSwitchRawReceiver = remote_ns.class_('RCSwitchRawReceiver', RemoteReceiver)
+RCSwitchTypeAReceiver = remote_ns.class_('RCSwitchTypeAReceiver', RCSwitchRawReceiver)
+RCSwitchTypeBReceiver = remote_ns.class_('RCSwitchTypeBReceiver', RCSwitchRawReceiver)
+RCSwitchTypeCReceiver = remote_ns.class_('RCSwitchTypeCReceiver', RCSwitchRawReceiver)
+RCSwitchTypeDReceiver = remote_ns.class_('RCSwitchTypeDReceiver', RCSwitchRawReceiver)
+
+
+def validate_raw(value):
+    if isinstance(value, dict):
+        return cv.Schema({
+            cv.GenerateID(): cv.declare_variable_id(int32),
+            vol.Required(CONF_DATA): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
+        })(value)
+    return validate_raw({
+        CONF_DATA: value
+    })
+
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RemoteReceiver),
+    vol.Optional(CONF_JVC): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_LG): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): cv.one_of(28, 32, int=True),
+    }),
+    vol.Optional(CONF_NEC): cv.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint16_t,
+    }),
+    vol.Optional(CONF_SAMSUNG): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_SONY): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=12): cv.one_of(12, 15, 20, int=True),
+    }),
+    vol.Optional(CONF_PANASONIC): cv.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_RC5): cv.Schema({
+        vol.Required(CONF_ADDRESS): vol.All(cv.hex_int, vol.Range(min=0, max=0x1F)),
+        vol.Required(CONF_COMMAND): vol.All(cv.hex_int, vol.Range(min=0, max=0x3F)),
+    }),
+    vol.Optional(CONF_RAW): validate_raw,
+    vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_C): RC_SWITCH_TYPE_C_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_D): RC_SWITCH_TYPE_D_SCHEMA,
+
+    cv.GenerateID(CONF_REMOTE_RECEIVER_ID): cv.use_variable_id(RemoteReceiverComponent),
+    cv.GenerateID(CONF_RECEIVER_ID): cv.declare_variable_id(RemoteReceiver),
+}), cv.has_exactly_one_key(*REMOTE_KEYS))
+
+
+def receiver_base(full_config):
+    name = full_config[CONF_NAME]
+    key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)
+    if key == CONF_JVC:
+        return JVCReceiver.new(name, config[CONF_DATA])
+    if key == CONF_LG:
+        return LGReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
+    if key == CONF_NEC:
+        return NECReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_PANASONIC:
+        return PanasonicReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_SAMSUNG:
+        return SamsungReceiver.new(name, config[CONF_DATA])
+    if key == CONF_SONY:
+        return SonyReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
+    if key == CONF_RC5:
+        return RC5Receiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_RAW:
+        arr = progmem_array(config[CONF_ID], config[CONF_DATA])
+        return RawReceiver.new(name, arr, len(config[CONF_DATA]))
+    if key == CONF_RC_SWITCH_RAW:
+        return RCSwitchRawReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                       binary_code(config[CONF_CODE]), len(config[CONF_CODE]))
+    if key == CONF_RC_SWITCH_TYPE_A:
+        return RCSwitchTypeAReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                         binary_code(config[CONF_GROUP]),
+                                         binary_code(config[CONF_DEVICE]),
+                                         config[CONF_STATE])
+    if key == CONF_RC_SWITCH_TYPE_B:
+        return RCSwitchTypeBReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                         config[CONF_ADDRESS], config[CONF_CHANNEL],
+                                         config[CONF_STATE])
+    if key == CONF_RC_SWITCH_TYPE_C:
+        return RCSwitchTypeCReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                         ord(config[CONF_FAMILY][0]) - ord('a'),
+                                         config[CONF_GROUP], config[CONF_DEVICE],
+                                         config[CONF_STATE])
+    if key == CONF_RC_SWITCH_TYPE_D:
+        return RCSwitchTypeDReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                         ord(config[CONF_GROUP][0]) - ord('a'),
+                                         config[CONF_DEVICE], config[CONF_STATE])
+
+    raise NotImplementedError("Unknown receiver type {}".format(config))
+
+
+def to_code(config):
+    for remote in get_variable(config[CONF_REMOTE_RECEIVER_ID]):
+        yield
+    rhs = receiver_base(config)
+    receiver = Pvariable(config[CONF_RECEIVER_ID], rhs)
+
+    binary_sensor.register_binary_sensor(remote.add_decoder(receiver), config)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_RECEIVER'

esphome/components/binary_sensor/status.py

@@ -0,0 +1,24 @@
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+StatusBinarySensor = binary_sensor.binary_sensor_ns.class_('StatusBinarySensor',
+                                                           binary_sensor.BinarySensor,
+                                                           Component)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(StatusBinarySensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_status_binary_sensor(config[CONF_NAME])
+    status = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(status, config)
+    setup_component(status, config)
+
+
+BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'

esphome/components/binary_sensor/template.py

@@ -0,0 +1,56 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, Component, bool_, optional
+
+TemplateBinarySensor = binary_sensor.binary_sensor_ns.class_('TemplateBinarySensor',
+                                                             binary_sensor.BinarySensor,
+                                                             Component)
+BinarySensorPublishAction = binary_sensor.binary_sensor_ns.class_('BinarySensorPublishAction',
+                                                                  Action)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateBinarySensor),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_binary_sensor(config[CONF_NAME])
+    var = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(var, config)
+    setup_component(var, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(bool_)):
+            yield
+        add(var.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_BINARY_SENSOR'
+
+CONF_BINARY_SENSOR_TEMPLATE_PUBLISH = 'binary_sensor.template.publish'
+BINARY_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(binary_sensor.BinarySensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.boolean),
+})
+
+
+@ACTION_REGISTRY.register(CONF_BINARY_SENSOR_TEMPLATE_PUBLISH,
+                          BINARY_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def binary_sensor_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_binary_sensor_publish_action(template_arg)
+    type = BinarySensorPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, bool_):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/cover/__init__.py

@@ -0,0 +1,98 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_types import Action, Nameable, esphome_ns
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+cover_ns = esphome_ns.namespace('cover')
+
+Cover = cover_ns.class_('Cover', Nameable)
+MQTTCoverComponent = cover_ns.class_('MQTTCoverComponent', mqtt.MQTTComponent)
+
+CoverState = cover_ns.class_('CoverState')
+COVER_OPEN = cover_ns.COVER_OPEN
+COVER_CLOSED = cover_ns.COVER_CLOSED
+
+validate_cover_state = cv.one_of('OPEN', 'CLOSED', upper=True)
+COVER_STATES = {
+    'OPEN': COVER_OPEN,
+    'CLOSED': COVER_CLOSED,
+}
+
+# Actions
+OpenAction = cover_ns.class_('OpenAction', Action)
+CloseAction = cover_ns.class_('CloseAction', Action)
+StopAction = cover_ns.class_('StopAction', Action)
+
+COVER_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(Cover),
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTCoverComponent),
+})
+
+COVER_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(COVER_SCHEMA.schema)
+
+
+def setup_cover_core_(cover_var, config):
+    if CONF_INTERNAL in config:
+        add(cover_var.set_internal(config[CONF_INTERNAL]))
+    setup_mqtt_component(cover_var.Pget_mqtt(), config)
+
+
+def setup_cover(cover_obj, config):
+    CORE.add_job(setup_cover_core_, cover_obj, config)
+
+
+BUILD_FLAGS = '-DUSE_COVER'
+
+CONF_COVER_OPEN = 'cover.open'
+COVER_OPEN_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Cover),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COVER_OPEN, COVER_OPEN_ACTION_SCHEMA)
+def cover_open_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_open_action(template_arg)
+    type = OpenAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_COVER_CLOSE = 'cover.close'
+COVER_CLOSE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Cover),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COVER_CLOSE, COVER_CLOSE_ACTION_SCHEMA)
+def cover_close_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_close_action(template_arg)
+    type = CloseAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_COVER_STOP = 'cover.stop'
+COVER_STOP_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Cover),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COVER_STOP, COVER_STOP_ACTION_SCHEMA)
+def cover_stop_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_stop_action(template_arg)
+    type = StopAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphome/components/cover/template.py

@@ -0,0 +1,79 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import cover
+import esphome.config_validation as cv
+from esphome.const import CONF_ASSUMED_STATE, CONF_CLOSE_ACTION, CONF_ID, CONF_LAMBDA, CONF_NAME, \
+    CONF_OPEN_ACTION, CONF_OPTIMISTIC, CONF_STATE, CONF_STOP_ACTION
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, optional
+from esphome.py_compat import string_types
+
+TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover)
+CoverPublishAction = cover.cover_ns.class_('CoverPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateCover),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_ASSUMED_STATE): cv.boolean,
+    vol.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_cover(config[CONF_NAME])
+    var = Pvariable(config[CONF_ID], rhs)
+
+    cover.setup_cover(var, config)
+    setup_component(var, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(cover.CoverState)):
+            yield
+        add(var.set_state_lambda(template_))
+    if CONF_OPEN_ACTION in config:
+        automation.build_automations(var.get_open_trigger(), [],
+                                     config[CONF_OPEN_ACTION])
+    if CONF_CLOSE_ACTION in config:
+        automation.build_automations(var.get_close_trigger(), [],
+                                     config[CONF_CLOSE_ACTION])
+    if CONF_STOP_ACTION in config:
+        automation.build_automations(var.get_stop_trigger(), [],
+                                     config[CONF_STOP_ACTION])
+    if CONF_OPTIMISTIC in config:
+        add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+    if CONF_ASSUMED_STATE in config:
+        add(var.set_assumed_state(config[CONF_ASSUMED_STATE]))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_COVER'
+
+CONF_COVER_TEMPLATE_PUBLISH = 'cover.template.publish'
+COVER_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(cover.Cover),
+    vol.Required(CONF_STATE): cv.templatable(cover.validate_cover_state),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COVER_TEMPLATE_PUBLISH,
+                          COVER_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def cover_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_cover_publish_action(template_arg)
+    type = CoverPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    state = config[CONF_STATE]
+    if isinstance(state, string_types):
+        template_ = cover.COVER_STATES[state]
+    else:
+        for template_ in templatable(state, args, cover.CoverState):
+            yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/custom_component.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+import esphome.config_validation as cv
+from esphome.const import CONF_COMPONENTS, CONF_ID, CONF_LAMBDA
+from esphome.cpp_generator import Pvariable, process_lambda, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Component, ComponentPtr, esphome_ns, std_vector
+
+CustomComponentConstructor = esphome_ns.class_('CustomComponentConstructor')
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(CustomComponentConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_COMPONENTS): cv.ensure_list(cv.Schema({
+        cv.GenerateID(): cv.declare_variable_id(Component)
+    }).extend(cv.COMPONENT_SCHEMA.schema)),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(ComponentPtr)):
+        yield
+
+    rhs = CustomComponentConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, comp_config in enumerate(config.get(CONF_COMPONENTS, [])):
+        comp = Pvariable(comp_config[CONF_ID], custom.get_component(i))
+        setup_component(comp, comp_config)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_COMPONENT'

esphome/components/dallas.py

@@ -0,0 +1,27 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DallasComponent = sensor.sensor_ns.class_('DallasComponent', PollingComponent)
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(DallasComponent),
+    vol.Required(CONF_PIN): pins.input_pin,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_dallas_component(config[CONF_PIN], config.get(CONF_UPDATE_INTERVAL))
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphome/components/debug.py

@@ -0,0 +1,14 @@
+import esphome.config_validation as cv
+from esphome.cpp_generator import add
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['logger']
+
+CONFIG_SCHEMA = cv.Schema({})
+
+
+def to_code(config):
+    add(App.make_debug_component())
+
+
+BUILD_FLAGS = '-DUSE_DEBUG_COMPONENT'

esphome/components/deep_sleep.py

@@ -0,0 +1,118 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv, pins
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.const import CONF_ID, CONF_MODE, CONF_NUMBER, CONF_PINS, CONF_RUN_CYCLES, \
+    CONF_RUN_DURATION, CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
+from esphome.cpp_generator import Pvariable, StructInitializer, add, get_variable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import Action, App, Component, esphome_ns, global_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
+
+
+DeepSleepComponent = esphome_ns.class_('DeepSleepComponent', Component)
+EnterDeepSleepAction = esphome_ns.class_('EnterDeepSleepAction', Action)
+PreventDeepSleepAction = esphome_ns.class_('PreventDeepSleepAction', Action)
+
+WakeupPinMode = esphome_ns.enum('WakeupPinMode')
+WAKEUP_PIN_MODES = {
+    'IGNORE': WakeupPinMode.WAKEUP_PIN_MODE_IGNORE,
+    'KEEP_AWAKE': WakeupPinMode.WAKEUP_PIN_MODE_KEEP_AWAKE,
+    'INVERT_WAKEUP': WakeupPinMode.WAKEUP_PIN_MODE_INVERT_WAKEUP,
+}
+
+esp_sleep_ext1_wakeup_mode_t = global_ns.enum('esp_sleep_ext1_wakeup_mode_t')
+Ext1Wakeup = esphome_ns.struct('Ext1Wakeup')
+EXT1_WAKEUP_MODES = {
+    'ALL_LOW': esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ALL_LOW,
+    'ANY_HIGH': esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ANY_HIGH,
+}
+
+CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
+CONF_ESP32_EXT1_WAKEUP = 'esp32_ext1_wakeup'
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(DeepSleepComponent),
+    vol.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema,
+                                           validate_pin_number),
+    vol.Optional(CONF_WAKEUP_PIN_MODE): vol.All(cv.only_on_esp32,
+                                                cv.one_of(*WAKEUP_PIN_MODES), upper=True),
+    vol.Optional(CONF_ESP32_EXT1_WAKEUP): vol.All(cv.only_on_esp32, cv.Schema({
+        vol.Required(CONF_PINS): cv.ensure_list(pins.shorthand_input_pin, validate_pin_number),
+        vol.Required(CONF_MODE): cv.one_of(*EXT1_WAKEUP_MODES, upper=True),
+    })),
+    vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
+
+    vol.Optional(CONF_RUN_CYCLES): cv.invalid("The run_cycles option has been removed in 1.11.0 as "
+                                              "it was essentially the same as a run_duration of 0s."
+                                              "Please use run_duration now.")
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_deep_sleep_component()
+    deep_sleep = Pvariable(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:
+        for pin in gpio_input_pin_expression(config[CONF_WAKEUP_PIN]):
+            yield
+        add(deep_sleep.set_wakeup_pin(pin))
+    if CONF_WAKEUP_PIN_MODE in config:
+        add(deep_sleep.set_wakeup_pin_mode(WAKEUP_PIN_MODES[config[CONF_WAKEUP_PIN_MODE]]))
+    if CONF_RUN_DURATION in config:
+        add(deep_sleep.set_run_duration(config[CONF_RUN_DURATION]))
+
+    if CONF_ESP32_EXT1_WAKEUP in config:
+        conf = config[CONF_ESP32_EXT1_WAKEUP]
+        mask = 0
+        for pin in conf[CONF_PINS]:
+            mask |= 1 << pin[CONF_NUMBER]
+        struct = StructInitializer(
+            Ext1Wakeup,
+            ('mask', mask),
+            ('wakeup_mode', EXT1_WAKEUP_MODES[conf[CONF_MODE]])
+        )
+        add(deep_sleep.set_ext1_wakeup(struct))
+
+    setup_component(deep_sleep, config)
+
+
+BUILD_FLAGS = '-DUSE_DEEP_SLEEP'
+
+CONF_DEEP_SLEEP_ENTER = 'deep_sleep.enter'
+DEEP_SLEEP_ENTER_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(DeepSleepComponent),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DEEP_SLEEP_ENTER, DEEP_SLEEP_ENTER_ACTION_SCHEMA)
+def deep_sleep_enter_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_enter_deep_sleep_action(template_arg)
+    type = EnterDeepSleepAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_DEEP_SLEEP_PREVENT = 'deep_sleep.prevent'
+DEEP_SLEEP_PREVENT_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(DeepSleepComponent),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DEEP_SLEEP_PREVENT, DEEP_SLEEP_PREVENT_ACTION_SCHEMA)
+def deep_sleep_prevent_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_prevent_deep_sleep_action(template_arg)
+    type = PreventDeepSleepAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphome/components/display/__init__.py

@@ -0,0 +1,127 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome import core
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+import esphome.config_validation as cv
+from esphome.const import CONF_LAMBDA, CONF_ROTATION, CONF_UPDATE_INTERVAL, CONF_PAGES, CONF_ID
+from esphome.core import CORE
+from esphome.cpp_generator import add, process_lambda, Pvariable, templatable, get_variable
+from esphome.cpp_types import esphome_ns, void, Action
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+display_ns = esphome_ns.namespace('display')
+DisplayBuffer = display_ns.class_('DisplayBuffer')
+DisplayPage = display_ns.class_('DisplayPage')
+DisplayPagePtr = DisplayPage.operator('ptr')
+DisplayBufferRef = DisplayBuffer.operator('ref')
+DisplayPageShowAction = display_ns.class_('DisplayPageShowAction', Action)
+DisplayPageShowNextAction = display_ns.class_('DisplayPageShowNextAction', Action)
+DisplayPageShowPrevAction = display_ns.class_('DisplayPageShowPrevAction', Action)
+
+DISPLAY_ROTATIONS = {
+    0: display_ns.DISPLAY_ROTATION_0_DEGREES,
+    90: display_ns.DISPLAY_ROTATION_90_DEGREES,
+    180: display_ns.DISPLAY_ROTATION_180_DEGREES,
+    270: display_ns.DISPLAY_ROTATION_270_DEGREES,
+}
+
+
+def validate_rotation(value):
+    value = cv.string(value)
+    if value.endswith(u"°"):
+        value = value[:-1]
+    try:
+        value = int(value)
+    except ValueError:
+        raise vol.Invalid(u"Expected integer for rotation")
+    return cv.one_of(*DISPLAY_ROTATIONS)(value)
+
+
+BASIC_DISPLAY_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+})
+
+FULL_DISPLAY_PLATFORM_SCHEMA = BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_ROTATION): validate_rotation,
+    vol.Optional(CONF_PAGES): vol.All(cv.ensure_list({
+        cv.GenerateID(): cv.declare_variable_id(DisplayPage),
+        vol.Required(CONF_LAMBDA): cv.lambda_,
+    }), vol.Length(min=1)),
+})
+
+
+def setup_display_core_(display_var, config):
+    if CONF_UPDATE_INTERVAL in config:
+        add(display_var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
+    if CONF_ROTATION in config:
+        add(display_var.set_rotation(DISPLAY_ROTATIONS[config[CONF_ROTATION]]))
+    if CONF_PAGES in config:
+        pages = []
+        for conf in config[CONF_PAGES]:
+            for lambda_ in process_lambda(conf[CONF_LAMBDA], [(DisplayBufferRef, 'it')],
+                                          return_type=void):
+                yield
+            var = Pvariable(conf[CONF_ID], DisplayPage.new(lambda_))
+            pages.append(var)
+        add(display_var.set_pages(pages))
+
+
+CONF_DISPLAY_PAGE_SHOW = 'display.page.show'
+DISPLAY_PAGE_SHOW_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayPage)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DISPLAY_PAGE_SHOW, DISPLAY_PAGE_SHOW_ACTION_SCHEMA)
+def display_page_show_to_code(config, action_id, template_arg, args):
+    type = DisplayPageShowAction.template(template_arg)
+    action = Pvariable(action_id, type.new(), type=type)
+    if isinstance(config[CONF_ID], core.Lambda):
+        for template_ in templatable(config[CONF_ID], args, DisplayPagePtr):
+            yield None
+        add(action.set_page(template_))
+    else:
+        for var in get_variable(config[CONF_ID]):
+            yield None
+        add(action.set_page(var))
+    yield action
+
+
+CONF_DISPLAY_PAGE_SHOW_NEXT = 'display.page.show_next'
+DISPLAY_PAGE_SHOW_NEXT_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayBuffer)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DISPLAY_PAGE_SHOW_NEXT, DISPLAY_PAGE_SHOW_NEXT_ACTION_SCHEMA)
+def display_page_show_next_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    type = DisplayPageShowNextAction.template(template_arg)
+    yield Pvariable(action_id, type.new(var), type=type)
+
+
+CONF_DISPLAY_PAGE_SHOW_PREVIOUS = 'display.page.show_previous'
+DISPLAY_PAGE_SHOW_PREVIOUS_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayBuffer)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DISPLAY_PAGE_SHOW_PREVIOUS, DISPLAY_PAGE_SHOW_PREVIOUS_ACTION_SCHEMA)
+def display_page_show_previous_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    type = DisplayPageShowPrevAction.template(template_arg)
+    yield Pvariable(action_id, type.new(var), type=type)
+
+
+def setup_display(display_var, config):
+    CORE.add_job(setup_display_core_, display_var, config)
+
+
+BUILD_FLAGS = '-DUSE_DISPLAY'

esphome/components/display/lcd_gpio.py

@@ -0,0 +1,76 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import display
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA_PINS, CONF_DIMENSIONS, CONF_ENABLE_PIN, CONF_ID, \
+    CONF_LAMBDA, CONF_RS_PIN, CONF_RW_PIN
+from esphome.cpp_generator import Pvariable, add, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, void
+
+LCDDisplay = display.display_ns.class_('LCDDisplay', PollingComponent)
+LCDDisplayRef = LCDDisplay.operator('ref')
+GPIOLCDDisplay = display.display_ns.class_('GPIOLCDDisplay', LCDDisplay)
+
+
+def validate_lcd_dimensions(value):
+    value = cv.dimensions(value)
+    if value[0] > 0x40:
+        raise vol.Invalid("LCD displays can't have more than 64 columns")
+    if value[1] > 4:
+        raise vol.Invalid("LCD displays can't have more than 4 rows")
+    return value
+
+
+def validate_pin_length(value):
+    if len(value) != 4 and len(value) != 8:
+        raise vol.Invalid("LCD Displays can either operate in 4-pin or 8-pin mode,"
+                          "not {}-pin mode".format(len(value)))
+    return value
+
+
+PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(GPIOLCDDisplay),
+    vol.Required(CONF_DIMENSIONS): validate_lcd_dimensions,
+
+    vol.Required(CONF_DATA_PINS): vol.All([pins.gpio_output_pin_schema], validate_pin_length),
+    vol.Required(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_RS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_RW_PIN): pins.gpio_output_pin_schema,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_gpio_lcd_display(config[CONF_DIMENSIONS][0], config[CONF_DIMENSIONS][1])
+    lcd = Pvariable(config[CONF_ID], rhs)
+    pins_ = []
+    for conf in config[CONF_DATA_PINS]:
+        for pin in gpio_output_pin_expression(conf):
+            yield
+        pins_.append(pin)
+    add(lcd.set_data_pins(*pins_))
+    for enable in gpio_output_pin_expression(config[CONF_ENABLE_PIN]):
+        yield
+    add(lcd.set_enable_pin(enable))
+
+    for rs in gpio_output_pin_expression(config[CONF_RS_PIN]):
+        yield
+    add(lcd.set_rs_pin(rs))
+
+    if CONF_RW_PIN in config:
+        for rw in gpio_output_pin_expression(config[CONF_RW_PIN]):
+            yield
+        add(lcd.set_rw_pin(rw))
+
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')],
+                                      return_type=void):
+            yield
+        add(lcd.set_writer(lambda_))
+
+    display.setup_display(lcd, config)
+    setup_component(lcd, config)
+
+
+BUILD_FLAGS = '-DUSE_LCD_DISPLAY'

esphome/components/display/lcd_pcf8574.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome.components import display, i2c
+from esphome.components.display.lcd_gpio import LCDDisplay, LCDDisplayRef, \
+    validate_lcd_dimensions
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DIMENSIONS, CONF_ID, CONF_LAMBDA
+from esphome.cpp_generator import Pvariable, add, process_lambda
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, void
+
+DEPENDENCIES = ['i2c']
+
+PCF8574LCDDisplay = display.display_ns.class_('PCF8574LCDDisplay', LCDDisplay, i2c.I2CDevice)
+
+PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PCF8574LCDDisplay),
+    vol.Required(CONF_DIMENSIONS): validate_lcd_dimensions,
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_pcf8574_lcd_display(config[CONF_DIMENSIONS][0], config[CONF_DIMENSIONS][1])
+    lcd = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_ADDRESS in config:
+        add(lcd.set_address(config[CONF_ADDRESS]))
+
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')],
+                                      return_type=void):
+            yield
+        add(lcd.set_writer(lambda_))
+
+    display.setup_display(lcd, config)
+    setup_component(lcd, config)
+
+
+BUILD_FLAGS = ['-DUSE_LCD_DISPLAY', '-DUSE_LCD_DISPLAY_PCF8574']

esphome/components/display/max7219.py

@@ -0,0 +1,51 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import display, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, \
+    CONF_SPI_ID
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, void
+
+DEPENDENCIES = ['spi']
+
+MAX7219Component = display.display_ns.class_('MAX7219Component', PollingComponent, spi.SPIDevice)
+MAX7219ComponentRef = MAX7219Component.operator('ref')
+
+PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MAX7219Component),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+
+    vol.Optional(CONF_NUM_CHIPS): vol.All(cv.uint8_t, vol.Range(min=1)),
+    vol.Optional(CONF_INTENSITY): vol.All(cv.uint8_t, vol.Range(min=0, max=15)),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_max7219(spi_, cs)
+    max7219 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_NUM_CHIPS in config:
+        add(max7219.set_num_chips(config[CONF_NUM_CHIPS]))
+    if CONF_INTENSITY in config:
+        add(max7219.set_intensity(config[CONF_INTENSITY]))
+
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(MAX7219ComponentRef, 'it')],
+                                      return_type=void):
+            yield
+        add(max7219.set_writer(lambda_))
+
+    display.setup_display(max7219, config)
+    setup_component(max7219, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX7219'

esphome/components/display/nextion.py

@@ -0,0 +1,36 @@
+from esphome.components import display, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent, void
+
+DEPENDENCIES = ['uart']
+
+Nextion = display.display_ns.class_('Nextion', PollingComponent, uart.UARTDevice)
+NextionRef = Nextion.operator('ref')
+
+PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(Nextion),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    rhs = App.make_nextion(uart_)
+    nextion = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(NextionRef, 'it')],
+                                      return_type=void):
+            yield
+        add(nextion.set_writer(lambda_))
+
+    display.setup_display(nextion, config)
+    setup_component(nextion, config)
+
+
+BUILD_FLAGS = '-DUSE_NEXTION'

esphome/components/display/ssd1306_i2c.py

@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import display
+from esphome.components.display import ssd1306_spi
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_EXTERNAL_VCC, CONF_ID, CONF_LAMBDA, CONF_MODEL, \
+    CONF_PAGES, CONF_RESET_PIN
+from esphome.cpp_generator import Pvariable, add, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, void
+
+DEPENDENCIES = ['i2c']
+
+I2CSSD1306 = display.display_ns.class_('I2CSSD1306', ssd1306_spi.SSD1306)
+
+PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(I2CSSD1306),
+    vol.Required(CONF_MODEL): ssd1306_spi.SSD1306_MODEL,
+    vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_EXTERNAL_VCC): cv.boolean,
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
+
+
+def to_code(config):
+    ssd = Pvariable(config[CONF_ID], App.make_i2c_ssd1306())
+    add(ssd.set_model(ssd1306_spi.MODELS[config[CONF_MODEL]]))
+
+    if CONF_RESET_PIN in config:
+        for reset in gpio_output_pin_expression(config[CONF_RESET_PIN]):
+            yield
+        add(ssd.set_reset_pin(reset))
+    if CONF_EXTERNAL_VCC in config:
+        add(ssd.set_external_vcc(config[CONF_EXTERNAL_VCC]))
+    if CONF_ADDRESS in config:
+        add(ssd.set_address(config[CONF_ADDRESS]))
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA],
+                                      [(display.DisplayBufferRef, 'it')], return_type=void):
+            yield
+        add(ssd.set_writer(lambda_))
+
+    display.setup_display(ssd, config)
+    setup_component(ssd, config)
+
+
+BUILD_FLAGS = '-DUSE_SSD1306'

esphome/components/display/ssd1306_spi.py

@@ -0,0 +1,71 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import display, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_DC_PIN, CONF_EXTERNAL_VCC, CONF_ID, CONF_LAMBDA, \
+    CONF_MODEL, CONF_RESET_PIN, CONF_SPI_ID, CONF_PAGES
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, void
+
+DEPENDENCIES = ['spi']
+
+SSD1306 = display.display_ns.class_('SSD1306', PollingComponent, display.DisplayBuffer)
+SPISSD1306 = display.display_ns.class_('SPISSD1306', SSD1306, spi.SPIDevice)
+SSD1306Model = display.display_ns.enum('SSD1306Model')
+
+MODELS = {
+    'SSD1306_128X32': SSD1306Model.SSD1306_MODEL_128_32,
+    'SSD1306_128X64': SSD1306Model.SSD1306_MODEL_128_64,
+    'SSD1306_96X16': SSD1306Model.SSD1306_MODEL_96_16,
+    'SSD1306_64X48': SSD1306Model.SSD1306_MODEL_64_48,
+    'SH1106_128X32': SSD1306Model.SH1106_MODEL_128_32,
+    'SH1106_128X64': SSD1306Model.SH1106_MODEL_128_64,
+    'SH1106_96X16': SSD1306Model.SH1106_MODEL_96_16,
+    'SH1106_64X48': SSD1306Model.SH1106_MODEL_64_48,
+}
+
+SSD1306_MODEL = cv.one_of(*MODELS, upper=True, space="_")
+
+PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SPISSD1306),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_MODEL): SSD1306_MODEL,
+    vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_EXTERNAL_VCC): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    for dc in gpio_output_pin_expression(config[CONF_DC_PIN]):
+        yield
+
+    rhs = App.make_spi_ssd1306(spi_, cs, dc)
+    ssd = Pvariable(config[CONF_ID], rhs)
+    add(ssd.set_model(MODELS[config[CONF_MODEL]]))
+
+    if CONF_RESET_PIN in config:
+        for reset in gpio_output_pin_expression(config[CONF_RESET_PIN]):
+            yield
+        add(ssd.set_reset_pin(reset))
+    if CONF_EXTERNAL_VCC in config:
+        add(ssd.set_external_vcc(config[CONF_EXTERNAL_VCC]))
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA],
+                                      [(display.DisplayBufferRef, 'it')], return_type=void):
+            yield
+        add(ssd.set_writer(lambda_))
+
+    display.setup_display(ssd, config)
+    setup_component(ssd, config)
+
+
+BUILD_FLAGS = '-DUSE_SSD1306'

esphome/components/display/waveshare_epaper.py

@@ -0,0 +1,93 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import display, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_BUSY_PIN, CONF_CS_PIN, CONF_DC_PIN, CONF_FULL_UPDATE_EVERY, \
+    CONF_ID, CONF_LAMBDA, CONF_MODEL, CONF_PAGES, CONF_RESET_PIN, CONF_SPI_ID
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App, PollingComponent, void
+
+DEPENDENCIES = ['spi']
+
+WaveshareEPaperTypeA = display.display_ns.WaveshareEPaperTypeA
+WaveshareEPaper = display.display_ns.class_('WaveshareEPaper',
+                                            PollingComponent, spi.SPIDevice, display.DisplayBuffer)
+
+WaveshareEPaperTypeAModel = display.display_ns.enum('WaveshareEPaperTypeAModel')
+WaveshareEPaperTypeBModel = display.display_ns.enum('WaveshareEPaperTypeBModel')
+
+MODELS = {
+    '1.54in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_1_54_IN),
+    '2.13in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_2_13_IN),
+    '2.90in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_2_9_IN),
+    '2.70in': ('b', WaveshareEPaperTypeBModel.WAVESHARE_EPAPER_2_7_IN),
+    '4.20in': ('b', WaveshareEPaperTypeBModel.WAVESHARE_EPAPER_4_2_IN),
+    '7.50in': ('b', WaveshareEPaperTypeBModel.WAVESHARE_EPAPER_7_5_IN),
+}
+
+
+def validate_full_update_every_only_type_a(value):
+    if CONF_FULL_UPDATE_EVERY not in value:
+        return value
+    if MODELS[value[CONF_MODEL]][0] != 'a':
+        raise vol.Invalid("The 'full_update_every' option is only available for models "
+                          "'1.54in', '2.13in' and '2.90in'.")
+    return value
+
+
+PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(WaveshareEPaper),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True),
+    vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
+    vol.Optional(CONF_FULL_UPDATE_EVERY): cv.uint32_t,
+}).extend(cv.COMPONENT_SCHEMA.schema), validate_full_update_every_only_type_a,
+                          cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    for dc in gpio_output_pin_expression(config[CONF_DC_PIN]):
+        yield
+
+    model_type, model = MODELS[config[CONF_MODEL]]
+    if model_type == 'a':
+        rhs = App.make_waveshare_epaper_type_a(spi_, cs, dc, model)
+        epaper = Pvariable(config[CONF_ID], rhs, type=WaveshareEPaperTypeA)
+    elif model_type == 'b':
+        rhs = App.make_waveshare_epaper_type_b(spi_, cs, dc, model)
+        epaper = Pvariable(config[CONF_ID], rhs, type=WaveshareEPaper)
+    else:
+        raise NotImplementedError()
+
+    if CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(display.DisplayBufferRef, 'it')],
+                                      return_type=void):
+            yield
+        add(epaper.set_writer(lambda_))
+    if CONF_RESET_PIN in config:
+        for reset in gpio_output_pin_expression(config[CONF_RESET_PIN]):
+            yield
+        add(epaper.set_reset_pin(reset))
+    if CONF_BUSY_PIN in config:
+        for reset in gpio_input_pin_expression(config[CONF_BUSY_PIN]):
+            yield
+        add(epaper.set_busy_pin(reset))
+    if CONF_FULL_UPDATE_EVERY in config:
+        add(epaper.set_full_update_every(config[CONF_FULL_UPDATE_EVERY]))
+
+    display.setup_display(epaper, config)
+    setup_component(epaper, config)
+
+
+BUILD_FLAGS = '-DUSE_WAVESHARE_EPAPER'

esphome/components/esp32_ble_beacon.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv
+from esphome.const import CONF_ID, CONF_SCAN_INTERVAL, CONF_TYPE, CONF_UUID, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable, RawExpression, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+CONFLICTS_WITH = ['esp32_ble_tracker']
+
+ESP32BLEBeacon = esphome_ns.class_('ESP32BLEBeacon', Component)
+
+CONF_MAJOR = 'major'
+CONF_MINOR = 'minor'
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLEBeacon),
+    vol.Required(CONF_TYPE): cv.one_of('IBEACON', upper=True),
+    vol.Required(CONF_UUID): cv.uuid,
+    vol.Optional(CONF_MAJOR): cv.uint16_t,
+    vol.Optional(CONF_MINOR): cv.uint16_t,
+    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    uuid = config[CONF_UUID].hex
+    uuid_arr = [RawExpression('0x{}'.format(uuid[i:i + 2])) for i in range(0, len(uuid), 2)]
+    rhs = App.make_esp32_ble_beacon(uuid_arr)
+    ble = Pvariable(config[CONF_ID], rhs)
+    if CONF_MAJOR in config:
+        add(ble.set_major(config[CONF_MAJOR]))
+    if CONF_MINOR in config:
+        add(ble.set_minor(config[CONF_MINOR]))
+
+    setup_component(ble, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_BEACON'

esphome/components/esp32_ble_tracker.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv
+from esphome.components import sensor
+from esphome.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
+from esphome.core import HexInt
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONF_ESP32_BLE_ID = 'esp32_ble_id'
+ESP32BLETracker = esphome_ns.class_('ESP32BLETracker', Component)
+XiaomiSensor = esphome_ns.class_('XiaomiSensor', sensor.Sensor)
+XiaomiDevice = esphome_ns.class_('XiaomiDevice')
+XIAOMI_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(XiaomiSensor)
+})
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLETracker),
+    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_seconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def make_address_array(address):
+    return [HexInt(i) for i in address.parts]
+
+
+def to_code(config):
+    rhs = App.make_esp32_ble_tracker()
+    ble = Pvariable(config[CONF_ID], rhs)
+    if CONF_SCAN_INTERVAL in config:
+        add(ble.set_scan_interval(config[CONF_SCAN_INTERVAL]))
+
+    setup_component(ble, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_TRACKER'

esphome/components/esp32_camera.py

@@ -0,0 +1,130 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv, pins
+from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_NAME, CONF_PIN, CONF_SCL, CONF_SDA, \
+    ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Nameable, PollingComponent, esphome_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+ESP32Camera = esphome_ns.class_('ESP32Camera', PollingComponent, Nameable)
+ESP32CameraFrameSize = esphome_ns.enum('ESP32CameraFrameSize')
+FRAME_SIZES = {
+    '160X120': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_160X120,
+    'QQVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_160X120,
+    '128x160': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_128X160,
+    'QQVGA2': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_128X160,
+    '176X144': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_176X144,
+    'QCIF': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_176X144,
+    '240X176': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_240X176,
+    'HQVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_240X176,
+    '320X240': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_320X240,
+    'QVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_320X240,
+    '400X296': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_400X296,
+    'CIF': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_400X296,
+    '640X480': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_640X480,
+    'VGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_640X480,
+    '800X600': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_800X600,
+    'SVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_800X600,
+    '1024X768': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1024X768,
+    'XGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1024X768,
+    '1280x1024': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1280X1024,
+    'SXGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1280X1024,
+    '1600X1200': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1600X1200,
+    'UXGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1600X1200,
+}
+
+CONF_DATA_PINS = 'data_pins'
+CONF_VSYNC_PIN = 'vsync_pin'
+CONF_HREF_PIN = 'href_pin'
+CONF_PIXEL_CLOCK_PIN = 'pixel_clock_pin'
+CONF_EXTERNAL_CLOCK = 'external_clock'
+CONF_I2C_PINS = 'i2c_pins'
+CONF_RESET_PIN = 'reset_pin'
+CONF_POWER_DOWN_PIN = 'power_down_pin'
+
+CONF_MAX_FRAMERATE = 'max_framerate'
+CONF_IDLE_FRAMERATE = 'idle_framerate'
+CONF_RESOLUTION = 'resolution'
+CONF_JPEG_QUALITY = 'jpeg_quality'
+CONF_VERTICAL_FLIP = 'vertical_flip'
+CONF_HORIZONTAL_MIRROR = 'horizontal_mirror'
+CONF_CONTRAST = 'contrast'
+CONF_BRIGHTNESS = 'brightness'
+CONF_SATURATION = 'saturation'
+CONF_TEST_PATTERN = 'test_pattern'
+
+camera_range_param = vol.All(cv.int_, vol.Range(min=-2, max=2))
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32Camera),
+    vol.Required(CONF_NAME): cv.string,
+    vol.Required(CONF_DATA_PINS): vol.All([pins.input_pin], vol.Length(min=8, max=8)),
+    vol.Required(CONF_VSYNC_PIN): pins.input_pin,
+    vol.Required(CONF_HREF_PIN): pins.input_pin,
+    vol.Required(CONF_PIXEL_CLOCK_PIN): pins.input_pin,
+    vol.Required(CONF_EXTERNAL_CLOCK): cv.Schema({
+        vol.Required(CONF_PIN): pins.output_pin,
+        vol.Optional(CONF_FREQUENCY, default='20MHz'): vol.All(cv.frequency, vol.In([20e6, 10e6])),
+    }),
+    vol.Required(CONF_I2C_PINS): cv.Schema({
+        vol.Required(CONF_SDA): pins.output_pin,
+        vol.Required(CONF_SCL): pins.output_pin,
+    }),
+    vol.Optional(CONF_RESET_PIN): pins.output_pin,
+    vol.Optional(CONF_POWER_DOWN_PIN): pins.output_pin,
+
+    vol.Optional(CONF_MAX_FRAMERATE, default='10 fps'): vol.All(cv.framerate,
+                                                                vol.Range(min=0, min_included=False,
+                                                                          max=60)),
+    vol.Optional(CONF_IDLE_FRAMERATE, default='0.1 fps'): vol.All(cv.framerate,
+                                                                  vol.Range(min=0, max=1)),
+    vol.Optional(CONF_RESOLUTION, default='640X480'): cv.one_of(*FRAME_SIZES, upper=True),
+    vol.Optional(CONF_JPEG_QUALITY, default=10): vol.All(cv.int_, vol.Range(min=10, max=63)),
+    vol.Optional(CONF_CONTRAST, default=0): camera_range_param,
+    vol.Optional(CONF_BRIGHTNESS, default=0): camera_range_param,
+    vol.Optional(CONF_SATURATION, default=0): camera_range_param,
+    vol.Optional(CONF_VERTICAL_FLIP, default=True): cv.boolean,
+    vol.Optional(CONF_HORIZONTAL_MIRROR, default=True): cv.boolean,
+    vol.Optional(CONF_TEST_PATTERN, default=False): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+SETTERS = {
+    CONF_DATA_PINS: 'set_data_pins',
+    CONF_VSYNC_PIN: 'set_vsync_pin',
+    CONF_HREF_PIN: 'set_href_pin',
+    CONF_PIXEL_CLOCK_PIN: 'set_pixel_clock_pin',
+    CONF_RESET_PIN: 'set_reset_pin',
+    CONF_POWER_DOWN_PIN: 'set_power_down_pin',
+    CONF_JPEG_QUALITY: 'set_jpeg_quality',
+    CONF_VERTICAL_FLIP: 'set_vertical_flip',
+    CONF_HORIZONTAL_MIRROR: 'set_horizontal_mirror',
+    CONF_CONTRAST: 'set_contrast',
+    CONF_BRIGHTNESS: 'set_brightness',
+    CONF_SATURATION: 'set_saturation',
+    CONF_TEST_PATTERN: 'set_test_pattern',
+}
+
+
+def to_code(config):
+    rhs = App.register_component(ESP32Camera.new(config[CONF_NAME]))
+    cam = Pvariable(config[CONF_ID], rhs)
+
+    for key, setter in SETTERS.items():
+        if key in config:
+            add(getattr(cam, setter)(config[key]))
+
+    extclk = config[CONF_EXTERNAL_CLOCK]
+    add(cam.set_external_clock(extclk[CONF_PIN], extclk[CONF_FREQUENCY]))
+    i2c_pins = config[CONF_I2C_PINS]
+    add(cam.set_i2c_pins(i2c_pins[CONF_SDA], i2c_pins[CONF_SCL]))
+    add(cam.set_max_update_interval(1000 / config[CONF_MAX_FRAMERATE]))
+    if config[CONF_IDLE_FRAMERATE] == 0:
+        add(cam.set_idle_update_interval(0))
+    else:
+        add(cam.set_idle_update_interval(1000 / config[CONF_IDLE_FRAMERATE]))
+    add(cam.set_frame_size(FRAME_SIZES[config[CONF_RESOLUTION]]))
+
+
+BUILD_FLAGS = ['-DUSE_ESP32_CAMERA', '-DBOARD_HAS_PSRAM']

esphome/components/esp32_touch.py

@@ -1,11 +1,14 @@
 import voluptuous as vol
 
-from esphomeyaml import config_validation as cv
-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
+from esphome import config_validation as cv
+from esphome.components import binary_sensor
+from esphome.const import CONF_HIGH_VOLTAGE_REFERENCE, CONF_ID, CONF_IIR_FILTER, \
+    CONF_LOW_VOLTAGE_REFERENCE, CONF_MEASUREMENT_DURATION, CONF_SETUP_MODE, CONF_SLEEP_DURATION, \
+    CONF_VOLTAGE_ATTENUATION, ESP_PLATFORM_ESP32
+from esphome.core import TimePeriod
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, global_ns
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -17,33 +20,34 @@ def validate_voltage(values):
         value = cv.string(value)
         if not value.endswith('V'):
             value += 'V'
-        if value not in values:
-            raise vol.Invalid('Must be one of {}'.format(values))
-        return value
+        return cv.one_of(*values)(value)
+
     return validator
 
 
 LOW_VOLTAGE_REFERENCE = {
-    '0.5V': 'TOUCH_LVOLT_0V5',
-    '0.6V': 'TOUCH_LVOLT_0V6',
-    '0.7V': 'TOUCH_LVOLT_0V7',
-    '0.8V': 'TOUCH_LVOLT_0V8',
+    '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': 'TOUCH_HVOLT_2V4',
-    '2.5V': 'TOUCH_HVOLT_2V5',
-    '2.6V': 'TOUCH_HVOLT_2V6',
-    '2.7V': 'TOUCH_HVOLT_2V7',
+    '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': 'TOUCH_HVOLT_ATTEN_1V5',
-    '1V': 'TOUCH_HVOLT_ATTEN_1V',
-    '0.5V': 'TOUCH_HVOLT_ATTEN_0V5',
-    '0V': 'TOUCH_HVOLT_ATTEN_0V',
+    '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,
+ESP32TouchComponent = binary_sensor.binary_sensor_ns.class_('ESP32TouchComponent', Component)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32TouchComponent),
     vol.Optional(CONF_SETUP_MODE): cv.boolean,
     vol.Optional(CONF_IIR_FILTER): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_SLEEP_DURATION):
@@ -53,18 +57,18 @@ CONFIG_SCHEMA = vol.Schema({
     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),
-})
+}).extend(cv.COMPONENT_SCHEMA.schema)
 
 
 def to_code(config):
     rhs = App.make_esp32_touch_component()
-    touch = Pvariable('binary_sensor::ESP32TouchComponent', config[CONF_ID], rhs)
+    touch = Pvariable(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)
+        sleep_duration = int(config[CONF_SLEEP_DURATION].total_microseconds * 0.15)
         add(touch.set_sleep_duration(sleep_duration))
     if CONF_MEASUREMENT_DURATION in config:
         measurement_duration = int(config[CONF_MEASUREMENT_DURATION].total_microseconds * 0.125)
@@ -79,5 +83,7 @@ def to_code(config):
         value = VOLTAGE_ATTENUATION[config[CONF_VOLTAGE_ATTENUATION]]
         add(touch.set_voltage_attenuation(value))
 
+    setup_component(touch, config)
+
 
 BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'

esphome/components/ethernet.py

@@ -0,0 +1,85 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import wifi
+import esphome.config_validation as cv
+from esphome.const import CONF_DOMAIN, CONF_ID, CONF_MANUAL_IP, CONF_STATIC_IP, CONF_TYPE, \
+    CONF_USE_ADDRESS, ESP_PLATFORM_ESP32
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression
+from esphome.cpp_types import App, Component, esphome_ns, global_ns
+
+CONFLICTS_WITH = ['wifi']
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONF_PHY_ADDR = 'phy_addr'
+CONF_MDC_PIN = 'mdc_pin'
+CONF_MDIO_PIN = 'mdio_pin'
+CONF_CLK_MODE = 'clk_mode'
+CONF_POWER_PIN = 'power_pin'
+
+EthernetType = esphome_ns.enum('EthernetType')
+ETHERNET_TYPES = {
+    'LAN8720': EthernetType.ETHERNET_TYPE_LAN8720,
+    'TLK110': EthernetType.ETHERNET_TYPE_TLK110,
+}
+
+eth_clock_mode_t = global_ns.enum('eth_clock_mode_t')
+CLK_MODES = {
+    'GPIO0_IN': eth_clock_mode_t.ETH_CLOCK_GPIO0_IN,
+    'GPIO0_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO0_OUT,
+    'GPIO16_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO16_OUT,
+    'GPIO17_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO17_OUT,
+}
+
+EthernetComponent = esphome_ns.class_('EthernetComponent', Component)
+
+
+def validate(config):
+    if CONF_USE_ADDRESS not in config:
+        if CONF_MANUAL_IP in config:
+            use_address = str(config[CONF_MANUAL_IP][CONF_STATIC_IP])
+        else:
+            use_address = CORE.name + config[CONF_DOMAIN]
+        config[CONF_USE_ADDRESS] = use_address
+    return config
+
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(EthernetComponent),
+    vol.Required(CONF_TYPE): cv.one_of(*ETHERNET_TYPES, upper=True),
+    vol.Required(CONF_MDC_PIN): pins.output_pin,
+    vol.Required(CONF_MDIO_PIN): pins.input_output_pin,
+    vol.Optional(CONF_CLK_MODE, default='GPIO0_IN'): cv.one_of(*CLK_MODES, upper=True, space='_'),
+    vol.Optional(CONF_PHY_ADDR, default=0): vol.All(cv.int_, vol.Range(min=0, max=31)),
+    vol.Optional(CONF_POWER_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_MANUAL_IP): wifi.STA_MANUAL_IP_SCHEMA,
+    vol.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
+    vol.Optional(CONF_USE_ADDRESS): cv.string_strict,
+
+    vol.Optional('hostname'): cv.invalid("The hostname option has been removed in 1.11.0"),
+}), validate)
+
+
+def to_code(config):
+    rhs = App.init_ethernet()
+    eth = Pvariable(config[CONF_ID], rhs)
+
+    add(eth.set_phy_addr(config[CONF_PHY_ADDR]))
+    add(eth.set_mdc_pin(config[CONF_MDC_PIN]))
+    add(eth.set_mdio_pin(config[CONF_MDIO_PIN]))
+    add(eth.set_type(ETHERNET_TYPES[config[CONF_TYPE]]))
+    add(eth.set_clk_mode(CLK_MODES[config[CONF_CLK_MODE]]))
+    add(eth.set_use_address(config[CONF_USE_ADDRESS]))
+
+    if CONF_POWER_PIN in config:
+        for pin in gpio_output_pin_expression(config[CONF_POWER_PIN]):
+            yield
+        add(eth.set_power_pin(pin))
+
+    if CONF_MANUAL_IP in config:
+        add(eth.set_manual_ip(wifi.manual_ip(config[CONF_MANUAL_IP])))
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_ETHERNET'

esphome/components/fan/__init__.py

@@ -0,0 +1,132 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_OSCILLATING, \
+    CONF_OSCILLATION_COMMAND_TOPIC, CONF_OSCILLATION_STATE_TOPIC, CONF_SPEED, \
+    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_types import Action, Application, Component, Nameable, bool_, esphome_ns
+from esphome.py_compat import string_types
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+fan_ns = esphome_ns.namespace('fan')
+FanState = fan_ns.class_('FanState', Nameable, Component)
+MQTTFanComponent = fan_ns.class_('MQTTFanComponent', mqtt.MQTTComponent)
+MakeFan = Application.struct('MakeFan')
+
+# Actions
+TurnOnAction = fan_ns.class_('TurnOnAction', Action)
+TurnOffAction = fan_ns.class_('TurnOffAction', Action)
+ToggleAction = fan_ns.class_('ToggleAction', Action)
+
+FanSpeed = fan_ns.enum('FanSpeed')
+FAN_SPEED_OFF = FanSpeed.FAN_SPEED_OFF
+FAN_SPEED_LOW = FanSpeed.FAN_SPEED_LOW
+FAN_SPEED_MEDIUM = FanSpeed.FAN_SPEED_MEDIUM
+FAN_SPEED_HIGH = FanSpeed.FAN_SPEED_HIGH
+
+FAN_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(FanState),
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTFanComponent),
+    vol.Optional(CONF_OSCILLATION_STATE_TOPIC): vol.All(cv.requires_component('mqtt'),
+                                                        cv.publish_topic),
+    vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): vol.All(cv.requires_component('mqtt'),
+                                                          cv.subscribe_topic),
+})
+
+FAN_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FAN_SCHEMA.schema)
+
+FAN_SPEEDS = {
+    'OFF': FAN_SPEED_OFF,
+    'LOW': FAN_SPEED_LOW,
+    'MEDIUM': FAN_SPEED_MEDIUM,
+    'HIGH': FAN_SPEED_HIGH,
+}
+
+
+def setup_fan_core_(fan_var, config):
+    if CONF_INTERNAL in config:
+        add(fan_var.set_internal(config[CONF_INTERNAL]))
+
+    mqtt_ = fan_var.Pget_mqtt()
+    if CONF_OSCILLATION_STATE_TOPIC in config:
+        add(mqtt_.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
+    if CONF_OSCILLATION_COMMAND_TOPIC in config:
+        add(mqtt_.set_custom_oscillation_command_topic(config[CONF_OSCILLATION_COMMAND_TOPIC]))
+    if CONF_SPEED_STATE_TOPIC in config:
+        add(mqtt_.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
+    if CONF_SPEED_COMMAND_TOPIC in config:
+        add(mqtt_.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
+    setup_mqtt_component(mqtt_, config)
+
+
+def setup_fan(fan_obj, config):
+    fan_var = Pvariable(config[CONF_ID], fan_obj, has_side_effects=False)
+    CORE.add_job(setup_fan_core_, fan_var, config)
+
+
+BUILD_FLAGS = '-DUSE_FAN'
+
+CONF_FAN_TOGGLE = 'fan.toggle'
+FAN_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(FanState),
+})
+
+
+@ACTION_REGISTRY.register(CONF_FAN_TOGGLE, FAN_TOGGLE_ACTION_SCHEMA)
+def fan_toggle_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_toggle_action(template_arg)
+    type = ToggleAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_FAN_TURN_OFF = 'fan.turn_off'
+FAN_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(FanState),
+})
+
+
+@ACTION_REGISTRY.register(CONF_FAN_TURN_OFF, FAN_TURN_OFF_ACTION_SCHEMA)
+def fan_turn_off_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_FAN_TURN_ON = 'fan.turn_on'
+FAN_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(FanState),
+    vol.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean),
+    vol.Optional(CONF_SPEED): cv.templatable(cv.one_of(*FAN_SPEEDS, upper=True)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_FAN_TURN_ON, FAN_TURN_ON_ACTION_SCHEMA)
+def fan_turn_on_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_OSCILLATING in config:
+        for template_ in templatable(config[CONF_OSCILLATING], args, bool_):
+            yield None
+        add(action.set_oscillating(template_))
+    if CONF_SPEED in config:
+        for template_ in templatable(config[CONF_SPEED], args, FanSpeed):
+            yield None
+        if isinstance(template_, string_types):
+            template_ = FAN_SPEEDS[template_]
+        add(action.set_speed(template_))
+    yield action

esphome/components/fan/binary.py

@@ -0,0 +1,30 @@
+import voluptuous as vol
+
+from esphome.components import fan, output
+import esphome.config_validation as cv
+from esphome.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
+from esphome.cpp_generator import add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+
+    rhs = App.make_fan(config[CONF_NAME])
+    fan_struct = variable(config[CONF_MAKE_ID], rhs)
+    add(fan_struct.Poutput.set_binary(output_))
+    if CONF_OSCILLATION_OUTPUT in config:
+        for oscillation_output in get_variable(config[CONF_OSCILLATION_OUTPUT]):
+            yield
+        add(fan_struct.Poutput.set_oscillation(oscillation_output))
+
+    fan.setup_fan(fan_struct.Pstate, config)
+    setup_component(fan_struct.Poutput, config)

esphome/components/fan/speed.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+from esphome.components import fan, output
+import esphome.config_validation as cv
+from esphome.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 esphome.cpp_generator import add, get_variable, variable
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.FloatOutput),
+    vol.Optional(CONF_SPEED_STATE_TOPIC): cv.publish_topic,
+    vol.Optional(CONF_SPEED_COMMAND_TOPIC): cv.subscribe_topic,
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+    vol.Optional(CONF_SPEED): cv.Schema({
+        vol.Required(CONF_LOW): cv.percentage,
+        vol.Required(CONF_MEDIUM): cv.percentage,
+        vol.Required(CONF_HIGH): cv.percentage,
+    }),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+    rhs = App.make_fan(config[CONF_NAME])
+    fan_struct = variable(config[CONF_MAKE_ID], rhs)
+    if CONF_SPEED in config:
+        speeds = config[CONF_SPEED]
+        add(fan_struct.Poutput.set_speed(output_,
+                                         speeds[CONF_LOW],
+                                         speeds[CONF_MEDIUM],
+                                         speeds[CONF_HIGH]))
+    else:
+        add(fan_struct.Poutput.set_speed(output_))
+
+    if CONF_OSCILLATION_OUTPUT in config:
+        for oscillation_output in get_variable(config[CONF_OSCILLATION_OUTPUT]):
+            yield
+        add(fan_struct.Poutput.set_oscillation(oscillation_output))
+
+    fan.setup_fan(fan_struct.Pstate, config)

esphome/components/font.py

@@ -0,0 +1,119 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome import core
+from esphome.components import display
+import esphome.config_validation as cv
+from esphome.const import CONF_FILE, CONF_GLYPHS, CONF_ID, CONF_SIZE
+from esphome.core import CORE, HexInt
+from esphome.cpp_generator import Pvariable, progmem_array, safe_exp
+from esphome.cpp_types import App, uint8
+from esphome.py_compat import sort_by_cmp
+
+DEPENDENCIES = ['display']
+MULTI_CONF = True
+
+Font = display.display_ns.class_('Font')
+Glyph = display.display_ns.class_('Glyph')
+
+
+def validate_glyphs(value):
+    if isinstance(value, list):
+        value = cv.Schema([cv.string])(value)
+    value = cv.Schema([cv.string])(list(value))
+
+    def comparator(x, y):
+        x_ = x.encode('utf-8')
+        y_ = y.encode('utf-8')
+
+        for c in range(min(len(x_), len(y_))):
+            if x_[c] < y_[c]:
+                return -1
+            if x_[c] > y_[c]:
+                return 1
+
+        if len(x_) < len(y_):
+            return -1
+        if len(x_) > len(y_):
+            return 1
+        raise vol.Invalid(u"Found duplicate glyph {}".format(x))
+
+    sort_by_cmp(value, comparator)
+    return value
+
+
+def validate_pillow_installed(value):
+    try:
+        import PIL
+    except ImportError:
+        raise vol.Invalid("Please install the pillow python package to use this feature. "
+                          "(pip install pillow)")
+
+    if PIL.__version__[0] < '4':
+        raise vol.Invalid("Please update your pillow installation to at least 4.0.x. "
+                          "(pip install -U pillow)")
+
+    return value
+
+
+def validate_truetype_file(value):
+    if value.endswith('.zip'):  # for Google Fonts downloads
+        raise vol.Invalid(u"Please unzip the font archive '{}' first and then use the .ttf files "
+                          u"inside.".format(value))
+    if not value.endswith('.ttf'):
+        raise vol.Invalid(u"Only truetype (.ttf) files are supported. Please make sure you're "
+                          u"using the correct format or rename the extension to .ttf")
+    return cv.file_(value)
+
+
+DEFAULT_GLYPHS = u' !"%()+,-.:0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz°'
+CONF_RAW_DATA_ID = 'raw_data_id'
+
+FONT_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(Font),
+    vol.Required(CONF_FILE): validate_truetype_file,
+    vol.Optional(CONF_GLYPHS, default=DEFAULT_GLYPHS): validate_glyphs,
+    vol.Optional(CONF_SIZE, default=20): vol.All(cv.int_, vol.Range(min=1)),
+    cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(uint8),
+})
+
+CONFIG_SCHEMA = vol.All(validate_pillow_installed, FONT_SCHEMA)
+
+
+def to_code(config):
+    from PIL import ImageFont
+
+    path = CORE.relative_path(config[CONF_FILE])
+    try:
+        font = ImageFont.truetype(path, config[CONF_SIZE])
+    except Exception as e:
+        raise core.EsphomeError(u"Could not load truetype file {}: {}".format(path, e))
+
+    ascent, descent = font.getmetrics()
+
+    glyph_args = {}
+    data = []
+    for glyph in config[CONF_GLYPHS]:
+        mask = font.getmask(glyph, mode='1')
+        _, (offset_x, offset_y) = font.font.getsize(glyph)
+        width, height = mask.size
+        width8 = ((width + 7) // 8) * 8
+        glyph_data = [0 for _ in range(height * width8 // 8)]  # noqa: F812
+        for y in range(height):
+            for x in range(width):
+                if not mask.getpixel((x, y)):
+                    continue
+                pos = x + y * width8
+                glyph_data[pos // 8] |= 0x80 >> (pos % 8)
+        glyph_args[glyph] = (len(data), offset_x, offset_y, width, height)
+        data += glyph_data
+
+    rhs = safe_exp([HexInt(x) for x in data])
+    prog_arr = progmem_array(config[CONF_RAW_DATA_ID], rhs)
+
+    glyphs = []
+    for glyph in config[CONF_GLYPHS]:
+        glyphs.append(Glyph(glyph, prog_arr, *glyph_args[glyph]))
+
+    rhs = App.make_font(glyphs, ascent, ascent + descent)
+    Pvariable(config[CONF_ID], rhs)

esphome/components/globals.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv
+from esphome.const import CONF_ID, CONF_INITIAL_VALUE, CONF_RESTORE_VALUE, CONF_TYPE
+from esphome.cpp_generator import Pvariable, RawExpression, TemplateArguments, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+GlobalVariableComponent = esphome_ns.class_('GlobalVariableComponent', Component)
+
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(GlobalVariableComponent),
+    vol.Required(CONF_TYPE): cv.string_strict,
+    vol.Optional(CONF_INITIAL_VALUE): cv.string_strict,
+    vol.Optional(CONF_RESTORE_VALUE): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    type_ = RawExpression(config[CONF_TYPE])
+    template_args = TemplateArguments(type_)
+    res_type = GlobalVariableComponent.template(template_args)
+    initial_value = None
+    if CONF_INITIAL_VALUE in config:
+        initial_value = RawExpression(config[CONF_INITIAL_VALUE])
+    rhs = App.Pmake_global_variable(template_args, initial_value)
+    glob = Pvariable(config[CONF_ID], rhs, type=res_type)
+
+    if config.get(CONF_RESTORE_VALUE, False):
+        hash_ = hash(config[CONF_ID].id) % 2**32
+        add(glob.set_restore_value(hash_))
+
+    setup_component(glob, config)

esphome/components/i2c.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_RECEIVE_TIMEOUT, CONF_SCAN, CONF_SCL, \
+    CONF_SDA
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+I2CComponent = esphome_ns.class_('I2CComponent', Component)
+I2CDevice = pins.I2CDevice
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(I2CComponent),
+    vol.Optional(CONF_SDA, default='SDA'): pins.input_pin,
+    vol.Optional(CONF_SCL, default='SCL'): pins.input_pin,
+    vol.Optional(CONF_FREQUENCY): vol.All(cv.frequency, vol.Range(min=0, min_included=False)),
+    vol.Optional(CONF_SCAN, default=True): cv.boolean,
+
+    vol.Optional(CONF_RECEIVE_TIMEOUT): cv.invalid("The receive_timeout option has been removed "
+                                                   "because timeouts are already handled by the "
+                                                   "low-level i2c interface.")
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_SCAN))
+    i2c = Pvariable(config[CONF_ID], rhs)
+    if CONF_FREQUENCY in config:
+        add(i2c.set_frequency(config[CONF_FREQUENCY]))
+
+    setup_component(i2c, config)
+
+
+BUILD_FLAGS = '-DUSE_I2C'
+
+LIB_DEPS = 'Wire'

esphome/components/image.py

@@ -0,0 +1,63 @@
+# coding=utf-8
+import logging
+
+import voluptuous as vol
+
+from esphome import core
+from esphome.components import display, font
+import esphome.config_validation as cv
+from esphome.const import CONF_FILE, CONF_ID, CONF_RESIZE
+from esphome.core import CORE, HexInt
+from esphome.cpp_generator import Pvariable, progmem_array, safe_exp
+from esphome.cpp_types import App, uint8
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['display']
+MULTI_CONF = True
+
+Image_ = display.display_ns.class_('Image')
+
+CONF_RAW_DATA_ID = 'raw_data_id'
+
+IMAGE_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(Image_),
+    vol.Required(CONF_FILE): cv.file_,
+    vol.Optional(CONF_RESIZE): cv.dimensions,
+    cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(uint8),
+})
+
+CONFIG_SCHEMA = vol.All(font.validate_pillow_installed, IMAGE_SCHEMA)
+
+
+def to_code(config):
+    from PIL import Image
+
+    path = CORE.relative_path(config[CONF_FILE])
+    try:
+        image = Image.open(path)
+    except Exception as e:
+        raise core.EsphomeError(u"Could not load image file {}: {}".format(path, e))
+
+    if CONF_RESIZE in config:
+        image.thumbnail(config[CONF_RESIZE])
+
+    image = image.convert('1', dither=Image.NONE)
+    width, height = image.size
+    if width > 500 or height > 500:
+        _LOGGER.warning("The image you requested is very big. Please consider using the resize "
+                        "parameter")
+    width8 = ((width + 7) // 8) * 8
+    data = [0 for _ in range(height * width8 // 8)]
+    for y in range(height):
+        for x in range(width):
+            if image.getpixel((x, y)):
+                continue
+            pos = x + y * width8
+            data[pos // 8] |= 0x80 >> (pos % 8)
+
+    rhs = safe_exp([HexInt(x) for x in data])
+    prog_arr = progmem_array(config[CONF_RAW_DATA_ID], rhs)
+
+    rhs = App.make_image(prog_arr, width, height)
+    Pvariable(config[CONF_ID], rhs)

esphome/components/interval.py

@@ -0,0 +1,24 @@
+import voluptuous as vol
+
+from esphome import automation
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent, Trigger, esphome_ns
+
+IntervalTrigger = esphome_ns.class_('IntervalTrigger', Trigger.template(), PollingComponent)
+
+CONFIG_SCHEMA = automation.validate_automation(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(IntervalTrigger),
+    vol.Required(CONF_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for conf in config:
+        rhs = App.register_component(IntervalTrigger.new(conf[CONF_INTERVAL]))
+        trigger = Pvariable(conf[CONF_ID], rhs)
+        setup_component(trigger, conf)
+
+        automation.build_automations(trigger, [], conf)

esphome/components/light/__init__.py

@@ -0,0 +1,501 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLORS, \
+    CONF_COLOR_TEMPERATURE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_DURATION, CONF_EFFECT, \
+    CONF_EFFECTS, CONF_EFFECT_ID, CONF_FLASH_LENGTH, CONF_GAMMA_CORRECT, CONF_GREEN, CONF_ID, \
+    CONF_INTERNAL, CONF_LAMBDA, CONF_MQTT_ID, CONF_NAME, CONF_NUM_LEDS, CONF_RANDOM, CONF_RED, \
+    CONF_SPEED, CONF_STATE, CONF_TRANSITION_LENGTH, CONF_UPDATE_INTERVAL, CONF_WHITE, CONF_WIDTH
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, StructInitializer, add, get_variable, process_lambda, \
+    templatable
+from esphome.cpp_types import Action, Application, Component, Nameable, esphome_ns, float_, \
+    std_string, uint32, void
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+# Base
+light_ns = esphome_ns.namespace('light')
+LightState = light_ns.class_('LightState', Nameable, Component)
+# Fake class for addressable lights
+AddressableLightState = light_ns.class_('LightState', LightState)
+MakeLight = Application.struct('MakeLight')
+LightOutput = light_ns.class_('LightOutput')
+AddressableLight = light_ns.class_('AddressableLight')
+AddressableLightRef = AddressableLight.operator('ref')
+
+# Actions
+ToggleAction = light_ns.class_('ToggleAction', Action)
+TurnOffAction = light_ns.class_('TurnOffAction', Action)
+TurnOnAction = light_ns.class_('TurnOnAction', Action)
+
+LightColorValues = light_ns.class_('LightColorValues')
+
+MQTTJSONLightComponent = light_ns.class_('MQTTJSONLightComponent', mqtt.MQTTComponent)
+
+# Effects
+LightEffect = light_ns.class_('LightEffect')
+RandomLightEffect = light_ns.class_('RandomLightEffect', LightEffect)
+LambdaLightEffect = light_ns.class_('LambdaLightEffect', LightEffect)
+StrobeLightEffect = light_ns.class_('StrobeLightEffect', LightEffect)
+StrobeLightEffectColor = light_ns.class_('StrobeLightEffectColor', LightEffect)
+FlickerLightEffect = light_ns.class_('FlickerLightEffect', LightEffect)
+AddressableLightEffect = light_ns.class_('AddressableLightEffect', LightEffect)
+AddressableLambdaLightEffect = light_ns.class_('AddressableLambdaLightEffect',
+                                               AddressableLightEffect)
+AddressableRainbowLightEffect = light_ns.class_('AddressableRainbowLightEffect',
+                                                AddressableLightEffect)
+AddressableColorWipeEffect = light_ns.class_('AddressableColorWipeEffect', AddressableLightEffect)
+AddressableColorWipeEffectColor = light_ns.struct('AddressableColorWipeEffectColor')
+AddressableScanEffect = light_ns.class_('AddressableScanEffect', AddressableLightEffect)
+AddressableTwinkleEffect = light_ns.class_('AddressableTwinkleEffect', AddressableLightEffect)
+AddressableRandomTwinkleEffect = light_ns.class_('AddressableRandomTwinkleEffect',
+                                                 AddressableLightEffect)
+AddressableFireworksEffect = light_ns.class_('AddressableFireworksEffect', AddressableLightEffect)
+AddressableFlickerEffect = light_ns.class_('AddressableFlickerEffect', AddressableLightEffect)
+
+CONF_STROBE = 'strobe'
+CONF_FLICKER = 'flicker'
+CONF_ADDRESSABLE_LAMBDA = 'addressable_lambda'
+CONF_ADDRESSABLE_RAINBOW = 'addressable_rainbow'
+CONF_ADDRESSABLE_COLOR_WIPE = 'addressable_color_wipe'
+CONF_ADDRESSABLE_SCAN = 'addressable_scan'
+CONF_ADDRESSABLE_TWINKLE = 'addressable_twinkle'
+CONF_ADDRESSABLE_RANDOM_TWINKLE = 'addressable_random_twinkle'
+CONF_ADDRESSABLE_FIREWORKS = 'addressable_fireworks'
+CONF_ADDRESSABLE_FLICKER = 'addressable_flicker'
+
+CONF_ADD_LED_INTERVAL = 'add_led_interval'
+CONF_REVERSE = 'reverse'
+CONF_MOVE_INTERVAL = 'move_interval'
+CONF_TWINKLE_PROBABILITY = 'twinkle_probability'
+CONF_PROGRESS_INTERVAL = 'progress_interval'
+CONF_SPARK_PROBABILITY = 'spark_probability'
+CONF_USE_RANDOM_COLOR = 'use_random_color'
+CONF_FADE_OUT_RATE = 'fade_out_rate'
+CONF_INTENSITY = 'intensity'
+
+BINARY_EFFECTS = [CONF_LAMBDA, CONF_STROBE]
+MONOCHROMATIC_EFFECTS = BINARY_EFFECTS + [CONF_FLICKER]
+RGB_EFFECTS = MONOCHROMATIC_EFFECTS + [CONF_RANDOM]
+ADDRESSABLE_EFFECTS = RGB_EFFECTS + [CONF_ADDRESSABLE_LAMBDA, CONF_ADDRESSABLE_RAINBOW,
+                                     CONF_ADDRESSABLE_COLOR_WIPE, CONF_ADDRESSABLE_SCAN,
+                                     CONF_ADDRESSABLE_TWINKLE, CONF_ADDRESSABLE_RANDOM_TWINKLE,
+                                     CONF_ADDRESSABLE_FIREWORKS, CONF_ADDRESSABLE_FLICKER]
+
+EFFECTS_SCHEMA = cv.Schema({
+    vol.Optional(CONF_LAMBDA): cv.Schema({
+        vol.Required(CONF_NAME): cv.string,
+        vol.Required(CONF_LAMBDA): cv.lambda_,
+        vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_RANDOM): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(RandomLightEffect),
+        vol.Optional(CONF_NAME, default="Random"): cv.string,
+        vol.Optional(CONF_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+        vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_STROBE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(StrobeLightEffect),
+        vol.Optional(CONF_NAME, default="Strobe"): cv.string,
+        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list(cv.Schema({
+            vol.Optional(CONF_STATE, default=True): cv.boolean,
+            vol.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
+            vol.Optional(CONF_RED, default=1.0): cv.percentage,
+            vol.Optional(CONF_GREEN, default=1.0): cv.percentage,
+            vol.Optional(CONF_BLUE, default=1.0): cv.percentage,
+            vol.Optional(CONF_WHITE, default=1.0): cv.percentage,
+            vol.Required(CONF_DURATION): cv.positive_time_period_milliseconds,
+        }), cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE,
+                                    CONF_WHITE)), vol.Length(min=2)),
+    }),
+    vol.Optional(CONF_FLICKER): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FlickerLightEffect),
+        vol.Optional(CONF_NAME, default="Flicker"): cv.string,
+        vol.Optional(CONF_ALPHA): cv.percentage,
+        vol.Optional(CONF_INTENSITY): cv.percentage,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_LAMBDA): cv.Schema({
+        vol.Required(CONF_NAME): cv.string,
+        vol.Required(CONF_LAMBDA): cv.lambda_,
+        vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_RAINBOW): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableRainbowLightEffect),
+        vol.Optional(CONF_NAME, default="Rainbow"): cv.string,
+        vol.Optional(CONF_SPEED): cv.uint32_t,
+        vol.Optional(CONF_WIDTH): cv.uint32_t,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_COLOR_WIPE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableColorWipeEffect),
+        vol.Optional(CONF_NAME, default="Color Wipe"): cv.string,
+        vol.Optional(CONF_COLORS): cv.ensure_list({
+            vol.Optional(CONF_RED, default=1.0): cv.percentage,
+            vol.Optional(CONF_GREEN, default=1.0): cv.percentage,
+            vol.Optional(CONF_BLUE, default=1.0): cv.percentage,
+            vol.Optional(CONF_WHITE, default=1.0): cv.percentage,
+            vol.Optional(CONF_RANDOM, default=False): cv.boolean,
+            vol.Required(CONF_NUM_LEDS): vol.All(cv.uint32_t, vol.Range(min=1)),
+        }),
+        vol.Optional(CONF_ADD_LED_INTERVAL): cv.positive_time_period_milliseconds,
+        vol.Optional(CONF_REVERSE): cv.boolean,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_SCAN): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableScanEffect),
+        vol.Optional(CONF_NAME, default="Scan"): cv.string,
+        vol.Optional(CONF_MOVE_INTERVAL): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_TWINKLE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableTwinkleEffect),
+        vol.Optional(CONF_NAME, default="Twinkle"): cv.string,
+        vol.Optional(CONF_TWINKLE_PROBABILITY): cv.percentage,
+        vol.Optional(CONF_PROGRESS_INTERVAL): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_RANDOM_TWINKLE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableRandomTwinkleEffect),
+        vol.Optional(CONF_NAME, default="Random Twinkle"): cv.string,
+        vol.Optional(CONF_TWINKLE_PROBABILITY): cv.percentage,
+        vol.Optional(CONF_PROGRESS_INTERVAL): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_FIREWORKS): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableFireworksEffect),
+        vol.Optional(CONF_NAME, default="Fireworks"): cv.string,
+        vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+        vol.Optional(CONF_SPARK_PROBABILITY): cv.percentage,
+        vol.Optional(CONF_USE_RANDOM_COLOR): cv.boolean,
+        vol.Optional(CONF_FADE_OUT_RATE): cv.uint8_t,
+    }),
+    vol.Optional(CONF_ADDRESSABLE_FLICKER): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableFlickerEffect),
+        vol.Optional(CONF_NAME, default="Addressable Flicker"): cv.string,
+        vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+        vol.Optional(CONF_INTENSITY): cv.percentage,
+    }),
+})
+
+
+def validate_effects(allowed_effects):
+    def validator(value):
+        is_list = isinstance(value, list)
+        if not is_list:
+            value = [value]
+        names = set()
+        ret = []
+        errors = []
+        for i, effect in enumerate(value):
+            path = [i] if is_list else []
+            if not isinstance(effect, dict):
+                errors.append(
+                    vol.Invalid("Each effect must be a dictionary, not {}".format(type(value)),
+                                path)
+                )
+                continue
+            if len(effect) > 1:
+                errors.append(
+                    vol.Invalid("Each entry in the 'effects:' option must be a single effect.",
+                                path)
+                )
+                continue
+            if not effect:
+                errors.append(
+                    vol.Invalid("Found no effect for the {}th entry in 'effects:'!".format(i),
+                                path)
+                )
+                continue
+            key = next(iter(effect.keys()))
+            if key.startswith('fastled'):
+                errors.append(
+                    vol.Invalid("FastLED effects have been renamed to addressable effects. "
+                                "Please use '{}'".format(key.replace('fastled', 'addressable')),
+                                path)
+                )
+                continue
+            if key not in allowed_effects:
+                errors.append(
+                    vol.Invalid("The effect '{}' does not exist or is not allowed for this "
+                                "light type".format(key), path)
+                )
+                continue
+            effect[key] = effect[key] or {}
+            try:
+                conf = EFFECTS_SCHEMA(effect)
+            except vol.Invalid as err:
+                err.prepend(path)
+                errors.append(err)
+                continue
+            name = conf[key][CONF_NAME]
+            if name in names:
+                errors.append(
+                    vol.Invalid(u"Found the effect name '{}' twice. All effects must have "
+                                u"unique names".format(name), [i])
+                )
+                continue
+            names.add(name)
+            ret.append(conf)
+        if errors:
+            raise vol.MultipleInvalid(errors)
+        return ret
+
+    return validator
+
+
+LIGHT_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(LightState),
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTJSONLightComponent),
+})
+
+LIGHT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(LIGHT_SCHEMA.schema)
+
+
+def build_effect(full_config):
+    key, config = next(iter(full_config.items()))
+    if key == CONF_LAMBDA:
+        lambda_ = None
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [], return_type=void):
+            yield None
+        yield LambdaLightEffect.new(config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL])
+    elif key == CONF_RANDOM:
+        rhs = RandomLightEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_TRANSITION_LENGTH in config:
+            add(effect.set_transition_length(config[CONF_TRANSITION_LENGTH]))
+        if CONF_UPDATE_INTERVAL in config:
+            add(effect.set_update_interval(config[CONF_UPDATE_INTERVAL]))
+        yield effect
+    elif key == CONF_STROBE:
+        rhs = StrobeLightEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        colors = []
+        for color in config.get(CONF_COLORS, []):
+            colors.append(StructInitializer(
+                StrobeLightEffectColor,
+                ('color', LightColorValues(color[CONF_STATE], color[CONF_BRIGHTNESS],
+                                           color[CONF_RED], color[CONF_GREEN], color[CONF_BLUE],
+                                           color[CONF_WHITE])),
+                ('duration', color[CONF_DURATION]),
+            ))
+        if colors:
+            add(effect.set_colors(colors))
+        yield effect
+    elif key == CONF_FLICKER:
+        rhs = FlickerLightEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_ALPHA in config:
+            add(effect.set_alpha(config[CONF_ALPHA]))
+        if CONF_INTENSITY in config:
+            add(effect.set_intensity(config[CONF_INTENSITY]))
+        yield effect
+    elif key == CONF_ADDRESSABLE_LAMBDA:
+        args = [(AddressableLightRef, 'it')]
+        for lambda_ in process_lambda(config[CONF_LAMBDA], args, return_type=void):
+            yield None
+        yield AddressableLambdaLightEffect.new(config[CONF_NAME], lambda_,
+                                               config[CONF_UPDATE_INTERVAL])
+    elif key == CONF_ADDRESSABLE_RAINBOW:
+        rhs = AddressableRainbowLightEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_SPEED in config:
+            add(effect.set_speed(config[CONF_SPEED]))
+        if CONF_WIDTH in config:
+            add(effect.set_width(config[CONF_WIDTH]))
+        yield effect
+    elif key == CONF_ADDRESSABLE_COLOR_WIPE:
+        rhs = AddressableColorWipeEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_ADD_LED_INTERVAL in config:
+            add(effect.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
+        if CONF_REVERSE in config:
+            add(effect.set_reverse(config[CONF_REVERSE]))
+        colors = []
+        for color in config.get(CONF_COLORS, []):
+            colors.append(StructInitializer(
+                AddressableColorWipeEffectColor,
+                ('r', int(round(color[CONF_RED] * 255))),
+                ('g', int(round(color[CONF_GREEN] * 255))),
+                ('b', int(round(color[CONF_BLUE] * 255))),
+                ('w', int(round(color[CONF_WHITE] * 255))),
+                ('random', color[CONF_RANDOM]),
+                ('num_leds', color[CONF_NUM_LEDS]),
+            ))
+        if colors:
+            add(effect.set_colors(colors))
+        yield effect
+    elif key == CONF_ADDRESSABLE_SCAN:
+        rhs = AddressableScanEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_MOVE_INTERVAL in config:
+            add(effect.set_move_interval(config[CONF_MOVE_INTERVAL]))
+        yield effect
+    elif key == CONF_ADDRESSABLE_TWINKLE:
+        rhs = AddressableTwinkleEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_TWINKLE_PROBABILITY in config:
+            add(effect.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
+        if CONF_PROGRESS_INTERVAL in config:
+            add(effect.set_progress_interval(config[CONF_PROGRESS_INTERVAL]))
+        yield effect
+    elif key == CONF_ADDRESSABLE_RANDOM_TWINKLE:
+        rhs = AddressableRandomTwinkleEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_TWINKLE_PROBABILITY in config:
+            add(effect.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
+        if CONF_PROGRESS_INTERVAL in config:
+            add(effect.set_progress_interval(config[CONF_PROGRESS_INTERVAL]))
+        yield effect
+    elif key == CONF_ADDRESSABLE_FIREWORKS:
+        rhs = AddressableFireworksEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_UPDATE_INTERVAL in config:
+            add(effect.set_update_interval(config[CONF_UPDATE_INTERVAL]))
+        if CONF_SPARK_PROBABILITY in config:
+            add(effect.set_spark_probability(config[CONF_SPARK_PROBABILITY]))
+        if CONF_USE_RANDOM_COLOR in config:
+            add(effect.set_spark_probability(config[CONF_USE_RANDOM_COLOR]))
+        if CONF_FADE_OUT_RATE in config:
+            add(effect.set_spark_probability(config[CONF_FADE_OUT_RATE]))
+        yield effect
+    elif key == CONF_ADDRESSABLE_FLICKER:
+        rhs = AddressableFlickerEffect.new(config[CONF_NAME])
+        effect = Pvariable(config[CONF_EFFECT_ID], rhs)
+        if CONF_UPDATE_INTERVAL in config:
+            add(effect.set_update_interval(config[CONF_UPDATE_INTERVAL]))
+        if CONF_INTENSITY in config:
+            add(effect.set_intensity(config[CONF_INTENSITY]))
+        yield effect
+    else:
+        raise NotImplementedError("Effect {} not implemented".format(next(config.keys())))
+
+
+def setup_light_core_(light_var, config):
+    if CONF_INTERNAL in config:
+        add(light_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_DEFAULT_TRANSITION_LENGTH in 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]))
+    effects = []
+    for conf in config.get(CONF_EFFECTS, []):
+        for effect in build_effect(conf):
+            yield
+        effects.append(effect)
+    if effects:
+        add(light_var.add_effects(effects))
+
+    setup_mqtt_component(light_var.Pget_mqtt(), config)
+
+
+def setup_light(light_obj, config):
+    light_var = Pvariable(config[CONF_ID], light_obj, has_side_effects=False)
+    CORE.add_job(setup_light_core_, light_var, config)
+
+
+BUILD_FLAGS = '-DUSE_LIGHT'
+
+CONF_LIGHT_TOGGLE = 'light.toggle'
+LIGHT_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(LightState),
+    vol.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
+})
+
+
+@ACTION_REGISTRY.register(CONF_LIGHT_TOGGLE, LIGHT_TOGGLE_ACTION_SCHEMA)
+def light_toggle_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_toggle_action(template_arg)
+    type = ToggleAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_TRANSITION_LENGTH in config:
+        for template_ in templatable(config[CONF_TRANSITION_LENGTH], args, uint32):
+            yield None
+        add(action.set_transition_length(template_))
+    yield action
+
+
+CONF_LIGHT_TURN_OFF = 'light.turn_off'
+LIGHT_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(LightState),
+    vol.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
+})
+
+
+@ACTION_REGISTRY.register(CONF_LIGHT_TURN_OFF, LIGHT_TURN_OFF_ACTION_SCHEMA)
+def light_turn_off_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_TRANSITION_LENGTH in config:
+        for template_ in templatable(config[CONF_TRANSITION_LENGTH], args, uint32):
+            yield None
+        add(action.set_transition_length(template_))
+    yield action
+
+
+CONF_LIGHT_TURN_ON = 'light.turn_on'
+LIGHT_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(LightState),
+    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_COLOR_TEMPERATURE): cv.templatable(cv.positive_float),
+    vol.Optional(CONF_EFFECT): cv.templatable(cv.string),
+})
+
+
+@ACTION_REGISTRY.register(CONF_LIGHT_TURN_ON, LIGHT_TURN_ON_ACTION_SCHEMA)
+def light_turn_on_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_TRANSITION_LENGTH in config:
+        for template_ in templatable(config[CONF_TRANSITION_LENGTH], args, uint32):
+            yield None
+        add(action.set_transition_length(template_))
+    if CONF_FLASH_LENGTH in config:
+        for template_ in templatable(config[CONF_FLASH_LENGTH], args, uint32):
+            yield None
+        add(action.set_flash_length(template_))
+    if CONF_BRIGHTNESS in config:
+        for template_ in templatable(config[CONF_BRIGHTNESS], args, float_):
+            yield None
+        add(action.set_brightness(template_))
+    if CONF_RED in config:
+        for template_ in templatable(config[CONF_RED], args, float_):
+            yield None
+        add(action.set_red(template_))
+    if CONF_GREEN in config:
+        for template_ in templatable(config[CONF_GREEN], args, float_):
+            yield None
+        add(action.set_green(template_))
+    if CONF_BLUE in config:
+        for template_ in templatable(config[CONF_BLUE], args, float_):
+            yield None
+        add(action.set_blue(template_))
+    if CONF_WHITE in config:
+        for template_ in templatable(config[CONF_WHITE], args, float_):
+            yield None
+        add(action.set_white(template_))
+    if CONF_COLOR_TEMPERATURE in config:
+        for template_ in templatable(config[CONF_COLOR_TEMPERATURE], args, float_):
+            yield None
+        add(action.set_color_temperature(template_))
+    if CONF_EFFECT in config:
+        for template_ in templatable(config[CONF_EFFECT], args, std_string):
+            yield None
+        add(action.set_effect(template_))
+    yield action

esphome/components/light/binary.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_EFFECTS, CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.BINARY_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+    rhs = App.make_binary_light(config[CONF_NAME], output_)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, config)
+    setup_component(light_struct.Pstate, config)

esphome/components/light/cwww.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+from esphome.components import light, output
+from esphome.components.light.rgbww import validate_cold_white_colder, \
+    validate_color_temperature
+import esphome.config_validation as cv
+from esphome.const import CONF_COLD_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
+    CONF_NAME, CONF_WARM_WHITE, CONF_WARM_WHITE_COLOR_TEMPERATURE
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
+    vol.Required(CONF_COLD_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_WARM_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): validate_color_temperature,
+    vol.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): validate_color_temperature,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.MONOCHROMATIC_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema), validate_cold_white_colder)
+
+
+def to_code(config):
+    for cold_white in get_variable(config[CONF_COLD_WHITE]):
+        yield
+    for warm_white in get_variable(config[CONF_WARM_WHITE]):
+        yield
+    rhs = App.make_cwww_light(config[CONF_NAME], config[CONF_COLD_WHITE_COLOR_TEMPERATURE],
+                              config[CONF_WARM_WHITE_COLOR_TEMPERATURE],
+                              cold_white, warm_white)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, config)
+    setup_component(light_struct.Pstate, config)

esphome/components/light/fastled_clockless.py

@@ -0,0 +1,108 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import light
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHIPSET, CONF_COLOR_CORRECT, CONF_DEFAULT_TRANSITION_LENGTH, \
+    CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, \
+    CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, CONF_RGB_ORDER
+from esphome.cpp_generator import RawExpression, TemplateArguments, add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
+
+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
+
+
+MakeFastLEDLight = Application.struct('MakeFastLEDLight')
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
+
+    vol.Required(CONF_CHIPSET): cv.one_of(*TYPES, upper=True),
+    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): cv.one_of(*RGB_ORDERS, upper=True),
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=3)),
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema), validate)
+
+
+def to_code(config):
+    rhs = App.make_fast_led_light(config[CONF_NAME])
+    make = variable(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:
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+        add(fast_led.set_power_supply(power_supply))
+
+    if CONF_COLOR_CORRECT in config:
+        r, g, b = config[CONF_COLOR_CORRECT]
+        add(fast_led.set_correction(r, g, b))
+
+    light.setup_light(make.Pstate, config)
+    setup_component(fast_led, config)
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
+
+LIB_DEPS = 'FastLED@3.2.0'

esphome/components/light/fastled_spi.py

@@ -0,0 +1,88 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import light
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHIPSET, CONF_CLOCK_PIN, CONF_COLOR_CORRECT, CONF_DATA_PIN, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
+    CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_POWER_SUPPLY, CONF_RGB_ORDER
+from esphome.cpp_generator import RawExpression, TemplateArguments, add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
+
+CHIPSETS = [
+    'LPD8806',
+    'WS2801',
+    'WS2803',
+    'SM16716',
+    'P9813',
+    'APA102',
+    'SK9822',
+    'DOTSTAR',
+]
+
+RGB_ORDERS = [
+    'RGB',
+    'RBG',
+    'GRB',
+    'GBR',
+    'BRG',
+    'BGR',
+]
+
+MakeFastLEDLight = Application.struct('MakeFastLEDLight')
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
+
+    vol.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
+    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): cv.one_of(*RGB_ORDERS, upper=True),
+    vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=3)),
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_fast_led_light(config[CONF_NAME])
+    make = variable(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:
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+        add(fast_led.set_power_supply(power_supply))
+
+    if CONF_COLOR_CORRECT in config:
+        r, g, b = config[CONF_COLOR_CORRECT]
+        add(fast_led.set_correction(r, g, b))
+
+    light.setup_light(make.Pstate, config)
+    setup_component(fast_led, config)
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
+
+LIB_DEPS = 'FastLED@3.2.0'

esphome/components/light/monochromatic.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, \
+    CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.FloatOutput),
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.MONOCHROMATIC_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+    rhs = App.make_monochromatic_light(config[CONF_NAME], output_)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, config)
+    setup_component(light_struct.Pstate, config)

esphome/components/light/neopixelbus.py

@@ -0,0 +1,190 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import light
+from esphome.components.light import AddressableLight
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CLOCK_PIN, CONF_COLOR_CORRECT, CONF_DATA_PIN, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_METHOD, \
+    CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, CONF_TYPE, CONF_VARIANT
+from esphome.core import CORE
+from esphome.cpp_generator import TemplateArguments, add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application, Component, global_ns
+
+NeoPixelBusLightOutputBase = light.light_ns.class_('NeoPixelBusLightOutputBase', Component,
+                                                   AddressableLight)
+ESPNeoPixelOrder = light.light_ns.namespace('ESPNeoPixelOrder')
+
+
+def validate_type(value):
+    value = cv.string(value).upper()
+    if 'R' not in value:
+        raise vol.Invalid("Must have R in type")
+    if 'G' not in value:
+        raise vol.Invalid("Must have G in type")
+    if 'B' not in value:
+        raise vol.Invalid("Must have B in type")
+    rest = set(value) - set('RGBW')
+    if rest:
+        raise vol.Invalid("Type has invalid color: {}".format(', '.join(rest)))
+    if len(set(value)) != len(value):
+        raise vol.Invalid("Type has duplicate color!")
+    return value
+
+
+def validate_variant(value):
+    value = cv.string(value).upper()
+    if value == 'WS2813':
+        value = 'WS2812X'
+    if value == 'WS2812':
+        value = '800KBPS'
+    if value == 'LC8812':
+        value = 'SK6812'
+    return cv.one_of(*VARIANTS)(value)
+
+
+def validate_method(value):
+    if value is None:
+        if CORE.is_esp32:
+            return 'ESP32_I2S_1'
+        if CORE.is_esp8266:
+            return 'ESP8266_DMA'
+        raise NotImplementedError
+
+    if CORE.is_esp32:
+        return cv.one_of(*ESP32_METHODS, upper=True, space='_')(value)
+    if CORE.is_esp8266:
+        return cv.one_of(*ESP8266_METHODS, upper=True, space='_')(value)
+    raise NotImplementedError
+
+
+def validate_method_pin(value):
+    method = value[CONF_METHOD]
+    method_pins = {
+        'ESP8266_DMA': [3],
+        'ESP8266_UART0': [1],
+        'ESP8266_ASYNC_UART0': [1],
+        'ESP8266_UART1': [2],
+        'ESP8266_ASYNC_UART1': [2],
+        'ESP32_I2S_0': list(range(0, 32)),
+        'ESP32_I2S_1': list(range(0, 32)),
+    }
+    if CORE.is_esp8266:
+        method_pins['BIT_BANG'] = list(range(0, 16))
+    elif CORE.is_esp32:
+        method_pins['BIT_BANG'] = list(range(0, 32))
+    pins_ = method_pins[method]
+    for opt in (CONF_PIN, CONF_CLOCK_PIN, CONF_DATA_PIN):
+        if opt in value and value[opt] not in pins_:
+            raise vol.Invalid("Method {} only supports pin(s) {}".format(
+                method, ', '.join('GPIO{}'.format(x) for x in pins_)
+            ), path=[CONF_METHOD])
+    return value
+
+
+VARIANTS = {
+    'WS2812X': 'Ws2812x',
+    'SK6812': 'Sk6812',
+    '800KBPS': '800Kbps',
+    '400KBPS': '400Kbps',
+}
+
+ESP8266_METHODS = {
+    'ESP8266_DMA': 'NeoEsp8266Dma{}Method',
+    'ESP8266_UART0': 'NeoEsp8266Uart0{}Method',
+    'ESP8266_UART1': 'NeoEsp8266Uart1{}Method',
+    'ESP8266_ASYNC_UART0': 'NeoEsp8266AsyncUart0{}Method',
+    'ESP8266_ASYNC_UART1': 'NeoEsp8266AsyncUart1{}Method',
+    'BIT_BANG': 'NeoEsp8266BitBang{}Method',
+}
+ESP32_METHODS = {
+    'ESP32_I2S_0': 'NeoEsp32I2s0{}Method',
+    'ESP32_I2S_1': 'NeoEsp32I2s1{}Method',
+    'BIT_BANG': 'NeoEsp32BitBang{}Method',
+}
+
+
+def format_method(config):
+    variant = VARIANTS[config[CONF_VARIANT]]
+    method = config[CONF_METHOD]
+    if CORE.is_esp8266:
+        return ESP8266_METHODS[method].format(variant)
+    if CORE.is_esp32:
+        return ESP32_METHODS[method].format(variant)
+    raise NotImplementedError
+
+
+def validate(config):
+    if CONF_PIN in config:
+        if CONF_CLOCK_PIN in config or CONF_DATA_PIN in config:
+            raise vol.Invalid("Cannot specify both 'pin' and 'clock_pin'+'data_pin'")
+        return config
+    if CONF_CLOCK_PIN in config:
+        if CONF_DATA_PIN not in config:
+            raise vol.Invalid("If you give clock_pin, you must also specify data_pin")
+        return config
+    raise vol.Invalid("Must specify at least one of 'pin' or 'clock_pin'+'data_pin'")
+
+
+MakeNeoPixelBusLight = Application.struct('MakeNeoPixelBusLight')
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeNeoPixelBusLight),
+
+    vol.Optional(CONF_TYPE, default='GRB'): validate_type,
+    vol.Optional(CONF_VARIANT, default='800KBPS'): validate_variant,
+    vol.Optional(CONF_METHOD, default=None): validate_method,
+    vol.Optional(CONF_PIN): pins.output_pin,
+    vol.Optional(CONF_CLOCK_PIN): pins.output_pin,
+    vol.Optional(CONF_DATA_PIN): pins.output_pin,
+
+    vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=4)),
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema), validate, validate_method_pin)
+
+
+def to_code(config):
+    type_ = config[CONF_TYPE]
+    has_white = 'W' in type_
+    if has_white:
+        func = App.make_neo_pixel_bus_rgbw_light
+        color_feat = global_ns.NeoRgbwFeature
+    else:
+        func = App.make_neo_pixel_bus_rgb_light
+        color_feat = global_ns.NeoRgbFeature
+
+    template = TemplateArguments(getattr(global_ns, format_method(config)), color_feat)
+    rhs = func(template, config[CONF_NAME])
+    make = variable(config[CONF_MAKE_ID], rhs, type=MakeNeoPixelBusLight.template(template))
+    output = make.Poutput
+
+    if CONF_PIN in config:
+        add(output.add_leds(config[CONF_NUM_LEDS], config[CONF_PIN]))
+    else:
+        add(output.add_leds(config[CONF_NUM_LEDS], config[CONF_CLOCK_PIN], config[CONF_DATA_PIN]))
+
+    add(output.set_pixel_order(getattr(ESPNeoPixelOrder, type_)))
+
+    if CONF_POWER_SUPPLY in config:
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+        add(output.set_power_supply(power_supply))
+
+    if CONF_COLOR_CORRECT in config:
+        add(output.set_correction(*config[CONF_COLOR_CORRECT]))
+
+    light.setup_light(make.Pstate, config)
+    setup_component(output, config)
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_NEO_PIXEL_BUS_LIGHT'
+
+LIB_DEPS = 'NeoPixelBus@2.4.1'

esphome/components/light/partition.py

@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+from esphome.components import light
+from esphome.components.light import AddressableLight
+import esphome.config_validation as cv
+from esphome.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_FROM, CONF_ID, \
+    CONF_MAKE_ID, CONF_NAME, CONF_SEGMENTS, CONF_TO
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_types import App, Application
+
+AddressableSegment = light.light_ns.class_('AddressableSegment')
+PartitionLightOutput = light.light_ns.class_('PartitionLightOutput', AddressableLight)
+MakePartitionLight = Application.struct('MakePartitionLight')
+
+
+def validate_from_to(value):
+    if value[CONF_FROM] > value[CONF_TO]:
+        raise vol.Invalid(u"From ({}) must not be larger than to ({})"
+                          u"".format(value[CONF_FROM], value[CONF_TO]))
+    return value
+
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakePartitionLight),
+
+    vol.Required(CONF_SEGMENTS): vol.All(cv.ensure_list({
+        vol.Required(CONF_ID): cv.use_variable_id(light.AddressableLightState),
+        vol.Required(CONF_FROM): cv.positive_int,
+        vol.Required(CONF_TO): cv.positive_int,
+    }, validate_from_to), vol.Length(min=1)),
+
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
+}))
+
+
+def to_code(config):
+    segments = []
+    for conf in config[CONF_SEGMENTS]:
+        for var in get_variable(conf[CONF_ID]):
+            yield
+        segments.append(AddressableSegment(var, conf[CONF_FROM],
+                                           conf[CONF_TO] - conf[CONF_FROM] + 1))
+
+    rhs = App.make_partition_light(config[CONF_NAME], segments)
+    make = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(make.Pstate, config)

esphome/components/light/rgb.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, \
+    CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
+    vol.Required(CONF_RED): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_GREEN): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_BLUE): cv.use_variable_id(output.FloatOutput),
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.RGB_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for red in get_variable(config[CONF_RED]):
+        yield
+    for green in get_variable(config[CONF_GREEN]):
+        yield
+    for blue in get_variable(config[CONF_BLUE]):
+        yield
+    rhs = App.make_rgb_light(config[CONF_NAME], red, green, blue)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, config)
+    setup_component(light_struct.Pstate, config)

esphome/components/light/rgbw.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, \
+    CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_WHITE
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
+    vol.Required(CONF_RED): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_GREEN): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_BLUE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.RGB_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for red in get_variable(config[CONF_RED]):
+        yield
+    for green in get_variable(config[CONF_GREEN]):
+        yield
+    for blue in get_variable(config[CONF_BLUE]):
+        yield
+    for white in get_variable(config[CONF_WHITE]):
+        yield
+    rhs = App.make_rgbw_light(config[CONF_NAME], red, green, blue, white)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, config)
+    setup_component(light_struct.Pstate, config)

esphome/components/light/rgbww.py

@@ -0,0 +1,65 @@
+import voluptuous as vol
+
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_BLUE, CONF_COLD_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, \
+    CONF_NAME, CONF_RED, CONF_WARM_WHITE, CONF_WARM_WHITE_COLOR_TEMPERATURE
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+
+def validate_color_temperature(value):
+    try:
+        val = cv.float_with_unit('Color Temperature', 'mireds')(value)
+    except vol.Invalid:
+        val = 1000000.0 / cv.float_with_unit('Color Temperature', 'K')(value)
+    if val < 0:
+        raise vol.Invalid("Color temperature cannot be negative")
+    return val
+
+
+def validate_cold_white_colder(value):
+    cw = value[CONF_COLD_WHITE_COLOR_TEMPERATURE]
+    ww = value[CONF_WARM_WHITE_COLOR_TEMPERATURE]
+    if cw > ww:
+        raise vol.Invalid("Cold white color temperature cannot be higher than warm white")
+    if cw == ww:
+        raise vol.Invalid("Cold white color temperature cannot be the same as warm white")
+    return value
+
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
+    vol.Required(CONF_RED): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_GREEN): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_BLUE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_COLD_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_WARM_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): validate_color_temperature,
+    vol.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): validate_color_temperature,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.RGB_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema), validate_cold_white_colder)
+
+
+def to_code(config):
+    for red in get_variable(config[CONF_RED]):
+        yield
+    for green in get_variable(config[CONF_GREEN]):
+        yield
+    for blue in get_variable(config[CONF_BLUE]):
+        yield
+    for cold_white in get_variable(config[CONF_COLD_WHITE]):
+        yield
+    for warm_white in get_variable(config[CONF_WARM_WHITE]):
+        yield
+    rhs = App.make_rgbww_light(config[CONF_NAME], config[CONF_COLD_WHITE_COLOR_TEMPERATURE],
+                               config[CONF_WARM_WHITE_COLOR_TEMPERATURE],
+                               red, green, blue, cold_white, warm_white)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, config)
+    setup_component(light_struct.Pstate, config)

esphome/components/logger.py

@@ -0,0 +1,184 @@
+import re
+
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY, LambdaAction
+import esphome.config_validation as cv
+from esphome.const import CONF_ARGS, CONF_BAUD_RATE, CONF_FORMAT, CONF_HARDWARE_UART, CONF_ID, \
+    CONF_LEVEL, CONF_LOGS, CONF_TAG, CONF_TX_BUFFER_SIZE
+from esphome.core import CORE, EsphomeError, Lambda
+from esphome.cpp_generator import Pvariable, RawExpression, add, process_lambda, statement
+from esphome.cpp_types import App, Component, esphome_ns, global_ns, void
+from esphome.py_compat import text_type
+
+LOG_LEVELS = {
+    'NONE': global_ns.ESPHOME_LOG_LEVEL_NONE,
+    'ERROR': global_ns.ESPHOME_LOG_LEVEL_ERROR,
+    'WARN': global_ns.ESPHOME_LOG_LEVEL_WARN,
+    'INFO': global_ns.ESPHOME_LOG_LEVEL_INFO,
+    'DEBUG': global_ns.ESPHOME_LOG_LEVEL_DEBUG,
+    'VERBOSE': global_ns.ESPHOME_LOG_LEVEL_VERBOSE,
+    'VERY_VERBOSE': global_ns.ESPHOME_LOG_LEVEL_VERY_VERBOSE,
+}
+
+LOG_LEVEL_TO_ESP_LOG = {
+    'ERROR': global_ns.ESP_LOGE,
+    'WARN': global_ns.ESP_LOGW,
+    'INFO': global_ns.ESP_LOGI,
+    'DEBUG': global_ns.ESP_LOGD,
+    'VERBOSE': global_ns.ESP_LOGV,
+    'VERY_VERBOSE': global_ns.ESP_LOGVV,
+}
+
+LOG_LEVEL_SEVERITY = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE', 'VERY_VERBOSE']
+
+UART_SELECTION_ESP32 = ['UART0', 'UART1', 'UART2']
+
+UART_SELECTION_ESP8266 = ['UART0', 'UART0_SWAP', 'UART1']
+
+HARDWARE_UART_TO_UART_SELECTION = {
+    'UART0': global_ns.UART_SELECTION_UART0,
+    'UART0_SWAP': global_ns.UART_SELECTION_UART0_SWAP,
+    'UART1': global_ns.UART_SELECTION_UART1,
+    'UART2': global_ns.UART_SELECTION_UART2,
+}
+
+HARDWARE_UART_TO_SERIAL = {
+    'UART0': 'Serial',
+    'UART0_SWAP': 'Serial',
+    'UART1': 'Serial1',
+    'UART2': 'Serial2',
+}
+
+# pylint: disable=invalid-name
+is_log_level = cv.one_of(*LOG_LEVELS, upper=True)
+
+
+def uart_selection(value):
+    if CORE.is_esp32:
+        return cv.one_of(*UART_SELECTION_ESP32, upper=True)(value)
+    if CORE.is_esp8266:
+        return cv.one_of(*UART_SELECTION_ESP8266, upper=True)(value)
+    raise NotImplementedError
+
+
+def validate_local_no_higher_than_global(value):
+    global_level = value.get(CONF_LEVEL, 'DEBUG')
+    for tag, level in value.get(CONF_LOGS, {}).items():
+        if LOG_LEVEL_SEVERITY.index(level) > LOG_LEVEL_SEVERITY.index(global_level):
+            raise EsphomeError(u"The local log level {} for {} must be less severe than the "
+                               u"global log level {}.".format(level, tag, global_level))
+    return value
+
+
+LogComponent = esphome_ns.class_('LogComponent', Component)
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(LogComponent),
+    vol.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
+    vol.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
+    vol.Optional(CONF_HARDWARE_UART, default='UART0'): uart_selection,
+    vol.Optional(CONF_LEVEL): is_log_level,
+    vol.Optional(CONF_LOGS): cv.Schema({
+        cv.string: is_log_level,
+    })
+}), validate_local_no_higher_than_global)
+
+
+def to_code(config):
+    rhs = App.init_log(config.get(CONF_BAUD_RATE),
+                       config.get(CONF_TX_BUFFER_SIZE),
+                       HARDWARE_UART_TO_UART_SELECTION[config.get(CONF_HARDWARE_UART)])
+    log = Pvariable(config[CONF_ID], rhs)
+    if CONF_LEVEL in config:
+        add(log.set_global_log_level(LOG_LEVELS[config[CONF_LEVEL]]))
+    for tag, level in config.get(CONF_LOGS, {}).items():
+        add(log.set_log_level(tag, LOG_LEVELS[level]))
+
+
+def required_build_flags(config):
+    flags = []
+    if CONF_LEVEL in config:
+        flags.append(u'-DESPHOME_LOG_LEVEL={}'.format(str(LOG_LEVELS[config[CONF_LEVEL]])))
+        this_severity = LOG_LEVEL_SEVERITY.index(config[CONF_LEVEL])
+        verbose_severity = LOG_LEVEL_SEVERITY.index('VERBOSE')
+        very_verbose_severity = LOG_LEVEL_SEVERITY.index('VERY_VERBOSE')
+        is_at_least_verbose = this_severity >= verbose_severity
+        is_at_least_very_verbose = this_severity >= very_verbose_severity
+        has_serial_logging = config.get(CONF_BAUD_RATE) != 0
+        if CORE.is_esp8266 and has_serial_logging and is_at_least_verbose:
+            debug_serial_port = HARDWARE_UART_TO_SERIAL[config.get(CONF_HARDWARE_UART)]
+            flags.append(u"-DDEBUG_ESP_PORT={}".format(debug_serial_port))
+            flags.append(u"-DLWIP_DEBUG")
+            DEBUG_COMPONENTS = {
+                'HTTP_CLIENT',
+                'HTTP_SERVER',
+                'HTTP_UPDATE',
+                'OTA',
+                'SSL',
+                'TLS_MEM',
+                'UPDATER',
+                'WIFI',
+            }
+            for comp in DEBUG_COMPONENTS:
+                flags.append(u"-DDEBUG_ESP_{}".format(comp))
+        if CORE.is_esp32 and is_at_least_verbose:
+            flags.append('-DCORE_DEBUG_LEVEL=5')
+        if CORE.is_esp32 and is_at_least_very_verbose:
+            flags.append('-DENABLE_I2C_DEBUG_BUFFER')
+
+    return flags
+
+
+def maybe_simple_message(schema):
+    def validator(value):
+        if isinstance(value, dict):
+            return cv.Schema(schema)(value)
+        return cv.Schema(schema)({CONF_FORMAT: value})
+
+    return validator
+
+
+def validate_printf(value):
+    # https://stackoverflow.com/questions/30011379/how-can-i-parse-a-c-format-string-in-python
+    # pylint: disable=anomalous-backslash-in-string
+    cfmt = u"""\
+    (                                  # start of capture group 1
+    %                                  # literal "%"
+    (?:                                # first option
+    (?:[-+0 #]{0,5})                   # optional flags
+    (?:\d+|\*)?                        # width
+    (?:\.(?:\d+|\*))?                  # precision
+    (?:h|l|ll|w|I|I32|I64)?            # size
+    [cCdiouxXeEfgGaAnpsSZ]             # type
+    ) |                                # OR
+    %%)                                # literal "%%"
+    """  # noqa
+    matches = re.findall(cfmt, value[CONF_FORMAT], flags=re.X)
+    if len(matches) != len(value[CONF_ARGS]):
+        raise vol.Invalid(u"Found {} printf-patterns ({}), but {} args were given!"
+                          u"".format(len(matches), u', '.join(matches), len(value[CONF_ARGS])))
+    return value
+
+
+CONF_LOGGER_LOG = 'logger.log'
+LOGGER_LOG_ACTION_SCHEMA = vol.All(maybe_simple_message({
+    vol.Required(CONF_FORMAT): cv.string,
+    vol.Optional(CONF_ARGS, default=list): cv.ensure_list(cv.lambda_),
+    vol.Optional(CONF_LEVEL, default="DEBUG"): cv.one_of(*LOG_LEVEL_TO_ESP_LOG, upper=True),
+    vol.Optional(CONF_TAG, default="main"): cv.string,
+}), validate_printf)
+
+
+@ACTION_REGISTRY.register(CONF_LOGGER_LOG, LOGGER_LOG_ACTION_SCHEMA)
+def logger_log_action_to_code(config, action_id, template_arg, args):
+    esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
+    args_ = [RawExpression(text_type(x)) for x in config[CONF_ARGS]]
+
+    text = text_type(statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args_)))
+
+    for lambda_ in process_lambda(Lambda(text), args, return_type=void):
+        yield None
+    rhs = LambdaAction.new(template_arg, lambda_)
+    type = LambdaAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphome/components/mcp23017.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, GPIOInputPin, GPIOOutputPin, io_ns, esphome_ns
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+MCP23017GPIOMode = esphome_ns.enum('MCP23017GPIOMode')
+MCP23017_GPIO_MODES = {
+    'INPUT': MCP23017GPIOMode.MCP23017_INPUT,
+    'INPUT_PULLUP': MCP23017GPIOMode.MCP23017_INPUT_PULLUP,
+    'OUTPUT': MCP23017GPIOMode.MCP23017_OUTPUT,
+}
+
+MCP23017GPIOInputPin = io_ns.class_('MCP23017GPIOInputPin', GPIOInputPin)
+MCP23017GPIOOutputPin = io_ns.class_('MCP23017GPIOOutputPin', GPIOOutputPin)
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(pins.MCP23017),
+    vol.Optional(CONF_ADDRESS, default=0x20): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_mcp23017_component(config[CONF_ADDRESS])
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_MCP23017'

esphome/components/mpr121.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+from esphome.components import i2c, binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+CONF_MPR121_ID = 'mpr121_id'
+MPR121Component = binary_sensor.binary_sensor_ns.class_('MPR121Component', Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(MPR121Component),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_mpr121(config.get(CONF_ADDRESS))
+    var = Pvariable(config[CONF_ID], rhs)
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_MPR121'

esphome/components/mqtt.py

@@ -0,0 +1,303 @@
+import re
+
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition
+from esphome.components import logger
+import esphome.config_validation as cv
+from esphome.const import CONF_AVAILABILITY, CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_CLIENT_ID, \
+    CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, \
+    CONF_ID, CONF_KEEPALIVE, CONF_LEVEL, CONF_LOG_TOPIC, CONF_ON_JSON_MESSAGE, CONF_ON_MESSAGE, \
+    CONF_PASSWORD, CONF_PAYLOAD, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PORT, \
+    CONF_QOS, CONF_REBOOT_TIMEOUT, CONF_RETAIN, CONF_SHUTDOWN_MESSAGE, CONF_SSL_FINGERPRINTS, \
+    CONF_STATE_TOPIC, CONF_TOPIC, CONF_TOPIC_PREFIX, CONF_TRIGGER_ID, CONF_USERNAME, \
+    CONF_WILL_MESSAGE
+from esphome.cpp_generator import Pvariable, RawExpression, StructInitializer, TemplateArguments, \
+    add, get_variable, process_lambda, templatable
+from esphome.cpp_types import Action, App, Component, JsonObjectConstRef, JsonObjectRef, \
+    Trigger, bool_, esphome_ns, optional, std_string, uint8, void
+
+
+def validate_message_just_topic(value):
+    value = cv.publish_topic(value)
+    return MQTT_MESSAGE_BASE({CONF_TOPIC: value})
+
+
+MQTT_MESSAGE_BASE = cv.Schema({
+    vol.Required(CONF_TOPIC): cv.publish_topic,
+    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 = esphome_ns.namespace('mqtt')
+MQTTMessage = mqtt_ns.struct('MQTTMessage')
+MQTTClientComponent = mqtt_ns.class_('MQTTClientComponent', Component)
+MQTTPublishAction = mqtt_ns.class_('MQTTPublishAction', Action)
+MQTTPublishJsonAction = mqtt_ns.class_('MQTTPublishJsonAction', Action)
+MQTTMessageTrigger = mqtt_ns.class_('MQTTMessageTrigger', Trigger.template(std_string))
+MQTTJsonMessageTrigger = mqtt_ns.class_('MQTTJsonMessageTrigger',
+                                        Trigger.template(JsonObjectConstRef))
+MQTTComponent = mqtt_ns.class_('MQTTComponent', Component)
+MQTTConnectedCondition = mqtt_ns.class_('MQTTConnectedCondition', Condition)
+
+
+def validate_config(value):
+    if CONF_PORT not in value:
+        parts = value[CONF_BROKER].split(u':')
+        if len(parts) == 2:
+            value[CONF_BROKER] = parts[0]
+            value[CONF_PORT] = cv.port(parts[1])
+        else:
+            value[CONF_PORT] = 1883
+    return value
+
+
+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.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(MQTTClientComponent),
+    vol.Required(CONF_BROKER): cv.string_strict,
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Optional(CONF_USERNAME, default=''): cv.string,
+    vol.Optional(CONF_PASSWORD, default=''): cv.string,
+    vol.Optional(CONF_CLIENT_ID): vol.All(cv.string, vol.Length(max=23)),
+    vol.Optional(CONF_DISCOVERY): vol.Any(cv.boolean, cv.one_of("CLEAN", upper=True)),
+    vol.Optional(CONF_DISCOVERY_RETAIN): cv.boolean,
+    vol.Optional(CONF_DISCOVERY_PREFIX): cv.publish_topic,
+    vol.Optional(CONF_BIRTH_MESSAGE): MQTT_MESSAGE_SCHEMA,
+    vol.Optional(CONF_WILL_MESSAGE): MQTT_MESSAGE_SCHEMA,
+    vol.Optional(CONF_SHUTDOWN_MESSAGE): MQTT_MESSAGE_SCHEMA,
+    vol.Optional(CONF_TOPIC_PREFIX): cv.publish_topic,
+    vol.Optional(CONF_LOG_TOPIC): vol.Any(None, MQTT_MESSAGE_BASE.extend({
+        vol.Optional(CONF_LEVEL): logger.is_log_level,
+    }), validate_message_just_topic),
+    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_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_ON_MESSAGE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTMessageTrigger),
+        vol.Required(CONF_TOPIC): cv.subscribe_topic,
+        vol.Optional(CONF_QOS): cv.mqtt_qos,
+        vol.Optional(CONF_PAYLOAD): cv.string_strict,
+    }),
+    vol.Optional(CONF_ON_JSON_MESSAGE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTJsonMessageTrigger),
+        vol.Required(CONF_TOPIC): cv.subscribe_topic,
+        vol.Optional(CONF_QOS, default=0): cv.mqtt_qos,
+    }),
+}), validate_config)
+
+
+def exp_mqtt_message(config):
+    if config is None:
+        return optional(TemplateArguments(MQTTMessage))
+    exp = StructInitializer(
+        MQTTMessage,
+        ('topic', config[CONF_TOPIC]),
+        ('payload', config.get(CONF_PAYLOAD, "")),
+        ('qos', config[CONF_QOS]),
+        ('retain', config[CONF_RETAIN])
+    )
+    return exp
+
+
+def to_code(config):
+    rhs = App.init_mqtt(config[CONF_BROKER], config[CONF_PORT],
+                        config[CONF_USERNAME], config[CONF_PASSWORD])
+    mqtt = Pvariable(config[CONF_ID], rhs)
+
+    discovery = config.get(CONF_DISCOVERY, True)
+    discovery_retain = config.get(CONF_DISCOVERY_RETAIN, True)
+    discovery_prefix = config.get(CONF_DISCOVERY_PREFIX, 'homeassistant')
+
+    if not discovery:
+        add(mqtt.disable_discovery())
+    elif discovery == "CLEAN":
+        add(mqtt.set_discovery_info(discovery_prefix, discovery_retain, True))
+    elif CONF_DISCOVERY_RETAIN in config or CONF_DISCOVERY_PREFIX in config:
+        add(mqtt.set_discovery_info(discovery_prefix, discovery_retain))
+
+    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 not birth_message:
+            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 not will_message:
+            add(mqtt.disable_last_will())
+        else:
+            add(mqtt.set_last_will(exp_mqtt_message(will_message)))
+    if CONF_SHUTDOWN_MESSAGE in config:
+        shutdown_message = config[CONF_SHUTDOWN_MESSAGE]
+        if not shutdown_message:
+            add(mqtt.disable_shutdown_message())
+        else:
+            add(mqtt.set_shutdown_message(exp_mqtt_message(shutdown_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 not log_topic:
+            add(mqtt.disable_log_message())
+        else:
+            add(mqtt.set_log_message_template(exp_mqtt_message(log_topic)))
+
+            if CONF_LEVEL in log_topic:
+                add(mqtt.set_log_level(logger.LOG_LEVELS[log_topic[CONF_LEVEL]]))
+
+    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(arr))
+
+    if CONF_KEEPALIVE in config:
+        add(mqtt.set_keep_alive(config[CONF_KEEPALIVE]))
+
+    if CONF_REBOOT_TIMEOUT in config:
+        add(mqtt.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+
+    for conf in config.get(CONF_ON_MESSAGE, []):
+        rhs = App.register_component(mqtt.make_message_trigger(conf[CONF_TOPIC]))
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        if CONF_QOS in conf:
+            add(trigger.set_qos(conf[CONF_QOS]))
+        if CONF_PAYLOAD in conf:
+            add(trigger.set_payload(conf[CONF_PAYLOAD]))
+        automation.build_automations(trigger, [(std_string, 'x')], conf)
+
+    for conf in config.get(CONF_ON_JSON_MESSAGE, []):
+        rhs = mqtt.make_json_message_trigger(conf[CONF_TOPIC], conf[CONF_QOS])
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(JsonObjectConstRef, 'x')], conf)
+
+
+CONF_MQTT_PUBLISH = 'mqtt.publish'
+MQTT_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_variable_id(MQTTClientComponent),
+    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),
+})
+
+
+@ACTION_REGISTRY.register(CONF_MQTT_PUBLISH, MQTT_PUBLISH_ACTION_SCHEMA)
+def mqtt_publish_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_publish_action(template_arg)
+    type = MQTTPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_TOPIC], args, std_string):
+        yield None
+    add(action.set_topic(template_))
+
+    for template_ in templatable(config[CONF_PAYLOAD], args, std_string):
+        yield None
+    add(action.set_payload(template_))
+    if CONF_QOS in config:
+        for template_ in templatable(config[CONF_QOS], args, uint8):
+            yield
+        add(action.set_qos(template_))
+    if CONF_RETAIN in config:
+        for template_ in templatable(config[CONF_RETAIN], args, bool_):
+            yield None
+        add(action.set_retain(template_))
+    yield action
+
+
+CONF_MQTT_PUBLISH_JSON = 'mqtt.publish_json'
+MQTT_PUBLISH_JSON_ACTION_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_variable_id(MQTTClientComponent),
+    vol.Required(CONF_TOPIC): cv.templatable(cv.publish_topic),
+    vol.Required(CONF_PAYLOAD): cv.lambda_,
+    vol.Optional(CONF_QOS): cv.mqtt_qos,
+    vol.Optional(CONF_RETAIN): cv.boolean,
+})
+
+
+@ACTION_REGISTRY.register(CONF_MQTT_PUBLISH_JSON, MQTT_PUBLISH_JSON_ACTION_SCHEMA)
+def mqtt_publish_json_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_publish_json_action(template_arg)
+    type = MQTTPublishJsonAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_TOPIC], args, std_string):
+        yield None
+    add(action.set_topic(template_))
+
+    args_ = args + [(JsonObjectRef, 'root')]
+    for lambda_ in process_lambda(config[CONF_PAYLOAD], args_, return_type=void):
+        yield None
+    add(action.set_payload(lambda_))
+    if CONF_QOS in config:
+        add(action.set_qos(config[CONF_QOS]))
+    if CONF_RETAIN in config:
+        add(action.set_retain(config[CONF_RETAIN]))
+    yield action
+
+
+def required_build_flags(config):
+    if CONF_SSL_FINGERPRINTS in config:
+        return '-DASYNC_TCP_SSL_ENABLED=1'
+    return None
+
+
+def get_default_topic_for(data, component_type, name, suffix):
+    whitelist = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
+    sanitized_name = ''.join(x for x in name.lower().replace(' ', '_') if x in whitelist)
+    return '{}/{}/{}/{}'.format(data.topic_prefix, component_type,
+                                sanitized_name, suffix)
+
+
+def setup_mqtt_component(obj, config):
+    if CONF_RETAIN in config:
+        add(obj.set_retain(config[CONF_RETAIN]))
+    if not config.get(CONF_DISCOVERY, True):
+        add(obj.disable_discovery())
+    if CONF_STATE_TOPIC in config:
+        add(obj.set_custom_state_topic(config[CONF_STATE_TOPIC]))
+    if CONF_COMMAND_TOPIC in config:
+        add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
+    if CONF_AVAILABILITY in config:
+        availability = config[CONF_AVAILABILITY]
+        if not availability:
+            add(obj.disable_availability())
+        else:
+            add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
+                                     availability[CONF_PAYLOAD_NOT_AVAILABLE]))
+
+
+LIB_DEPS = 'AsyncMqttClient@0.8.2'
+BUILD_FLAGS = '-DUSE_MQTT'
+
+CONF_MQTT_CONNECTED = 'mqtt.connected'
+MQTT_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
+
+
+@CONDITION_REGISTRY.register(CONF_MQTT_CONNECTED, MQTT_CONNECTED_CONDITION_SCHEMA)
+def mqtt_connected_to_code(config, condition_id, template_arg, args):
+    rhs = MQTTConnectedCondition.new(template_arg)
+    type = MQTTConnectedCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/my9231.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import (CONF_BIT_DEPTH, CONF_CLOCK_PIN, CONF_DATA_PIN, CONF_ID,
+                           CONF_NUM_CHANNELS, CONF_NUM_CHIPS, CONF_UPDATE_ON_BOOT)
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+MY9231OutputComponent = output.output_ns.class_('MY9231OutputComponent', Component)
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(MY9231OutputComponent),
+    vol.Required(CONF_DATA_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_CLOCK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_NUM_CHANNELS): vol.All(vol.Coerce(int),
+                                             vol.Range(3, 1020)),
+    vol.Optional(CONF_NUM_CHIPS): vol.All(vol.Coerce(int),
+                                          vol.Range(1, 255)),
+    vol.Optional(CONF_BIT_DEPTH): cv.one_of(8, 12, 14, 16, int=True),
+    vol.Optional(CONF_UPDATE_ON_BOOT): vol.Coerce(bool),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for di in gpio_output_pin_expression(config[CONF_DATA_PIN]):
+        yield
+    for dcki in gpio_output_pin_expression(config[CONF_CLOCK_PIN]):
+        yield
+    rhs = App.make_my9231_component(di, dcki)
+    my9231 = Pvariable(config[CONF_ID], rhs)
+    if CONF_NUM_CHANNELS in config:
+        add(my9231.set_num_channels(config[CONF_NUM_CHANNELS]))
+    if CONF_NUM_CHIPS in config:
+        add(my9231.set_num_chips(config[CONF_NUM_CHIPS]))
+    if CONF_BIT_DEPTH in config:
+        add(my9231.set_bit_depth(config[CONF_BIT_DEPTH]))
+    if CONF_UPDATE_ON_BOOT in config:
+        add(my9231.set_update(config[CONF_UPDATE_ON_BOOT]))
+    setup_component(my9231, config)
+
+
+BUILD_FLAGS = '-DUSE_MY9231_OUTPUT'

esphome/components/ota.py

@@ -0,0 +1,57 @@
+import logging
+
+import voluptuous as vol
+
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_OTA, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Component, esphome_ns
+
+_LOGGER = logging.getLogger(__name__)
+
+OTAComponent = esphome_ns.class_('OTAComponent', Component)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(OTAComponent),
+    vol.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Optional(CONF_PASSWORD): cv.string,
+})
+
+
+def to_code(config):
+    rhs = App.init_ota()
+    ota = Pvariable(config[CONF_ID], rhs)
+    if CONF_PASSWORD in config:
+        add(ota.set_auth_password(config[CONF_PASSWORD]))
+    if CONF_PORT in config:
+        add(ota.set_port(config[CONF_PORT]))
+    if config[CONF_SAFE_MODE]:
+        add(ota.start_safe_mode())
+
+
+def get_port(config):
+    if CONF_PORT in config[CONF_OTA]:
+        return config[CONF_OTA][CONF_PORT]
+    if CORE.is_esp32:
+        return 3232
+    if CORE.is_esp8266:
+        return 8266
+    raise NotImplementedError
+
+
+def get_auth(config):
+    return config[CONF_OTA].get(CONF_PASSWORD, '')
+
+
+BUILD_FLAGS = '-DUSE_OTA'
+REQUIRED_BUILD_FLAGS = '-DUSE_NEW_OTA'
+
+
+def lib_deps(config):
+    if CORE.is_esp32:
+        return ['Update']
+    if CORE.is_esp8266:
+        return ['Hash']
+    raise NotImplementedError

esphome/components/output/__init__.py

@@ -0,0 +1,114 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_LEVEL, CONF_MAX_POWER, \
+    CONF_MIN_POWER, CONF_POWER_SUPPLY
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_types import Action, esphome_ns, float_
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+BINARY_OUTPUT_SCHEMA = cv.Schema({
+    vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
+    vol.Optional(CONF_INVERTED): cv.boolean,
+})
+
+BINARY_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(BINARY_OUTPUT_SCHEMA.schema)
+
+FLOAT_OUTPUT_SCHEMA = BINARY_OUTPUT_SCHEMA.extend({
+    vol.Optional(CONF_MAX_POWER): cv.percentage,
+    vol.Optional(CONF_MIN_POWER): cv.percentage,
+})
+
+FLOAT_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FLOAT_OUTPUT_SCHEMA.schema)
+
+output_ns = esphome_ns.namespace('output')
+BinaryOutput = output_ns.class_('BinaryOutput')
+BinaryOutputPtr = BinaryOutput.operator('ptr')
+FloatOutput = output_ns.class_('FloatOutput', BinaryOutput)
+FloatOutputPtr = FloatOutput.operator('ptr')
+
+# Actions
+TurnOffAction = output_ns.class_('TurnOffAction', Action)
+TurnOnAction = output_ns.class_('TurnOnAction', Action)
+SetLevelAction = output_ns.class_('SetLevelAction', Action)
+
+
+def setup_output_platform_(obj, config, skip_power_supply=False):
+    if CONF_INVERTED in config:
+        add(obj.set_inverted(config[CONF_INVERTED]))
+    if not skip_power_supply and CONF_POWER_SUPPLY in config:
+        power_supply = None
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+        add(obj.set_power_supply(power_supply))
+    if CONF_MAX_POWER in config:
+        add(obj.set_max_power(config[CONF_MAX_POWER]))
+    if CONF_MIN_POWER in config:
+        add(obj.set_min_power(config[CONF_MIN_POWER]))
+
+
+def setup_output_platform(obj, config, skip_power_supply=False):
+    CORE.add_job(setup_output_platform_, obj, config, skip_power_supply)
+
+
+def register_output(var, config):
+    output_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    CORE.add_job(setup_output_platform_, output_var, config)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'
+
+CONF_OUTPUT_TURN_ON = 'output.turn_on'
+OUTPUT_TURN_ON_ACTION = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(BinaryOutput),
+})
+
+
+@ACTION_REGISTRY.register(CONF_OUTPUT_TURN_ON, OUTPUT_TURN_ON_ACTION)
+def output_turn_on_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_OUTPUT_TURN_OFF = 'output.turn_off'
+OUTPUT_TURN_OFF_ACTION = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(BinaryOutput)
+})
+
+
+@ACTION_REGISTRY.register(CONF_OUTPUT_TURN_OFF, OUTPUT_TURN_OFF_ACTION)
+def output_turn_off_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_OUTPUT_SET_LEVEL = 'output.set_level'
+OUTPUT_SET_LEVEL_ACTION = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(FloatOutput),
+    vol.Required(CONF_LEVEL): cv.templatable(cv.percentage),
+})
+
+
+@ACTION_REGISTRY.register(CONF_OUTPUT_SET_LEVEL, OUTPUT_SET_LEVEL_ACTION)
+def output_set_level_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_set_level_action(template_arg)
+    type = SetLevelAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_LEVEL], args, float_):
+        yield None
+    add(action.set_level(template_))
+    yield action

esphome/components/output/copy.py

@@ -0,0 +1,58 @@
+import voluptuous as vol
+
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_OUTPUTS, CONF_TYPE
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+
+BinaryCopyOutput = output.output_ns.class_('BinaryCopyOutput', output.BinaryOutput)
+FloatCopyOutput = output.output_ns.class_('FloatCopyOutput', output.FloatOutput)
+
+BINARY_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(BinaryCopyOutput),
+    vol.Required(CONF_TYPE): 'binary',
+    vol.Required(CONF_OUTPUTS): cv.ensure_list(cv.use_variable_id(output.BinaryOutput)),
+})
+
+FLOAT_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(FloatCopyOutput),
+    vol.Required(CONF_TYPE): 'float',
+    vol.Required(CONF_OUTPUTS): cv.ensure_list(cv.use_variable_id(output.FloatOutput)),
+})
+
+
+def validate_copy_output(value):
+    if not isinstance(value, dict):
+        raise vol.Invalid("Value must be dict")
+    type = cv.string_strict(value.get(CONF_TYPE, 'float')).lower()
+    value[CONF_TYPE] = type
+    if type == 'binary':
+        return BINARY_SCHEMA(value)
+    if type == 'float':
+        return FLOAT_SCHEMA(value)
+    raise vol.Invalid("type must either be binary or float, not {}!".format(type))
+
+
+PLATFORM_SCHEMA = validate_copy_output
+
+
+def to_code(config):
+    outputs = []
+    for out in config[CONF_OUTPUTS]:
+        for var in get_variable(out):
+            yield
+        outputs.append(var)
+
+    klass = {
+        'binary': BinaryCopyOutput,
+        'float': FloatCopyOutput,
+    }[config[CONF_TYPE]]
+    rhs = klass.new(outputs)
+    gpio = Pvariable(config[CONF_ID], rhs)
+
+    output.setup_output_platform(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_COPY_OUTPUT'

esphome/components/output/custom.py

@@ -0,0 +1,68 @@
+import voluptuous as vol
+
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_OUTPUTS, CONF_TYPE
+from esphome.cpp_generator import process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomBinaryOutputConstructor = output.output_ns.class_('CustomBinaryOutputConstructor')
+CustomFloatOutputConstructor = output.output_ns.class_('CustomFloatOutputConstructor')
+
+BINARY_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomBinaryOutputConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_TYPE): 'binary',
+    vol.Required(CONF_OUTPUTS):
+        cv.ensure_list(output.BINARY_OUTPUT_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(output.BinaryOutput),
+        })),
+})
+
+FLOAT_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomFloatOutputConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_TYPE): 'float',
+    vol.Required(CONF_OUTPUTS):
+        cv.ensure_list(output.FLOAT_OUTPUT_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(output.FloatOutput),
+        })),
+})
+
+
+def validate_custom_output(value):
+    if not isinstance(value, dict):
+        raise vol.Invalid("Value must be dict")
+    if CONF_TYPE not in value:
+        raise vol.Invalid("type not specified!")
+    type = cv.string_strict(value[CONF_TYPE]).lower()
+    value[CONF_TYPE] = type
+    if type == 'binary':
+        return BINARY_SCHEMA(value)
+    if type == 'float':
+        return FLOAT_SCHEMA(value)
+    raise vol.Invalid("type must either be binary or float, not {}!".format(type))
+
+
+PLATFORM_SCHEMA = validate_custom_output
+
+
+def to_code(config):
+    type = config[CONF_TYPE]
+    if type == 'binary':
+        ret_type = output.BinaryOutputPtr
+        klass = CustomBinaryOutputConstructor
+    else:
+        ret_type = output.FloatOutputPtr
+        klass = CustomFloatOutputConstructor
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(ret_type)):
+        yield
+
+    rhs = klass(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_OUTPUTS]):
+        output.register_output(custom.get_output(i), conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_OUTPUT'

esphome/components/output/esp8266_pwm.py

@@ -0,0 +1,42 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_NUMBER, CONF_PIN, ESP_PLATFORM_ESP8266
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
+
+
+def valid_pwm_pin(value):
+    num = value[CONF_NUMBER]
+    cv.one_of(0, 1, 2, 3, 4, 5, 9, 10, 12, 13, 14, 15, 16)(num)
+    return value
+
+
+ESP8266PWMOutput = output.output_ns.class_('ESP8266PWMOutput', output.FloatOutput, Component)
+
+PLATFORM_SCHEMA = output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(ESP8266PWMOutput),
+    vol.Required(CONF_PIN): vol.All(pins.internal_gpio_output_pin_schema, valid_pwm_pin),
+    vol.Optional(CONF_FREQUENCY): vol.All(cv.frequency, vol.Range(min=1.0e-6)),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_esp8266_pwm_output(pin)
+    gpio = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_FREQUENCY in config:
+        add(gpio.set_frequency(config[CONF_FREQUENCY]))
+
+    output.setup_output_platform(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP8266_PWM_OUTPUT'

esphome/components/output/gpio.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_PIN
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+GPIOBinaryOutputComponent = output.output_ns.class_('GPIOBinaryOutputComponent',
+                                                    output.BinaryOutput, Component)
+
+PLATFORM_SCHEMA = output.BINARY_OUTPUT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(GPIOBinaryOutputComponent),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_gpio_output(pin)
+    gpio = Pvariable(config[CONF_ID], rhs)
+    output.setup_output_platform(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_OUTPUT'

esphome/components/output/ledc.py

@@ -1,11 +1,13 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import output
-from esphomeyaml.const import APB_CLOCK_FREQ, CONF_BIT_DEPTH, CONF_CHANNEL, CONF_FREQUENCY, \
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import APB_CLOCK_FREQ, CONF_BIT_DEPTH, CONF_CHANNEL, CONF_FREQUENCY, \
     CONF_ID, CONF_PIN, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Pvariable, add
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -15,16 +17,19 @@ def validate_frequency_bit_depth(obj):
     bit_depth = obj.get(CONF_BIT_DEPTH, 12)
     max_freq = APB_CLOCK_FREQ / (2**bit_depth)
     if frequency > max_freq:
-        raise vol.Invalid('Maximum frequency for bit depth {} is {}'.format(bit_depth, max_freq))
+        raise vol.Invalid('Maximum frequency for bit depth {} is {}Hz'.format(bit_depth, max_freq))
     return obj
 
 
-PLATFORM_SCHEMA = vol.All(output.FLOAT_PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): vol.All(pins.output_pin, vol.Range(min=0, max=33)),
+LEDCOutputComponent = output.output_ns.class_('LEDCOutputComponent', output.FloatOutput, Component)
+
+PLATFORM_SCHEMA = vol.All(output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(LEDCOutputComponent),
+    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(cv.COMPONENT_SCHEMA.schema), validate_frequency_bit_depth)
 
 
 def to_code(config):
@@ -32,10 +37,11 @@ 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(config[CONF_ID], rhs)
     if CONF_CHANNEL in config:
         add(ledc.set_channel(config[CONF_CHANNEL]))
     output.setup_output_platform(ledc, config)
+    setup_component(ledc, config)
 
 
 BUILD_FLAGS = '-DUSE_LEDC_OUTPUT'

esphome/components/output/my9231.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome.components import output
+from esphome.components.my9231 import MY9231OutputComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_ID, CONF_MY9231_ID, CONF_POWER_SUPPLY
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+
+DEPENDENCIES = ['my9231']
+
+Channel = MY9231OutputComponent.class_('Channel', output.FloatOutput)
+
+PLATFORM_SCHEMA = output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(Channel),
+    vol.Required(CONF_CHANNEL): vol.All(vol.Coerce(int),
+                                        vol.Range(min=0, max=65535)),
+    cv.GenerateID(CONF_MY9231_ID): cv.use_variable_id(MY9231OutputComponent),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    power_supply = None
+    if CONF_POWER_SUPPLY in config:
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+    my9231 = None
+    for my9231 in get_variable(config[CONF_MY9231_ID]):
+        yield
+    rhs = my9231.create_channel(config[CONF_CHANNEL], power_supply)
+    out = Pvariable(config[CONF_ID], rhs)
+    output.setup_output_platform(out, config, skip_power_supply=True)
+    setup_component(out, config)
+
+
+BUILD_FLAGS = '-DUSE_MY9231_OUTPUT'

esphome/components/output/pca9685.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphome.components import output
+from esphome.components.pca9685 import PCA9685OutputComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY
+from esphome.cpp_generator import Pvariable, get_variable
+
+DEPENDENCIES = ['pca9685']
+
+Channel = PCA9685OutputComponent.class_('Channel', output.FloatOutput)
+
+PLATFORM_SCHEMA = output.FLOAT_OUTPUT_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(Channel),
+    vol.Required(CONF_CHANNEL): vol.All(vol.Coerce(int),
+                                        vol.Range(min=0, max=15)),
+    cv.GenerateID(CONF_PCA9685_ID): cv.use_variable_id(PCA9685OutputComponent),
+})
+
+
+def to_code(config):
+    power_supply = None
+    if CONF_POWER_SUPPLY in config:
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+    for pca9685 in get_variable(config[CONF_PCA9685_ID]):
+        yield
+    rhs = pca9685.create_channel(config[CONF_CHANNEL], power_supply)
+    out = Pvariable(config[CONF_ID], rhs)
+    output.setup_output_platform(out, config, skip_power_supply=True)
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphome/components/pca9685.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import i2c, output
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_FREQUENCY, CONF_ID
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+PCA9685OutputComponent = output.output_ns.class_('PCA9685OutputComponent',
+                                                 Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(PCA9685OutputComponent),
+    vol.Required(CONF_FREQUENCY): vol.All(cv.frequency,
+                                          vol.Range(min=23.84, max=1525.88)),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_pca9685_component(config.get(CONF_FREQUENCY))
+    pca9685 = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(pca9685.set_address(config[CONF_ADDRESS]))
+    setup_component(pca9685, config)
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphome/components/pcf8574.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_PCF8575
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, GPIOInputPin, GPIOOutputPin, io_ns
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+PCF8574GPIOMode = io_ns.enum('PCF8574GPIOMode')
+PCF8675_GPIO_MODES = {
+    'INPUT': PCF8574GPIOMode.PCF8574_INPUT,
+    'INPUT_PULLUP': PCF8574GPIOMode.PCF8574_INPUT_PULLUP,
+    'OUTPUT': PCF8574GPIOMode.PCF8574_OUTPUT,
+}
+
+PCF8574GPIOInputPin = io_ns.class_('PCF8574GPIOInputPin', GPIOInputPin)
+PCF8574GPIOOutputPin = io_ns.class_('PCF8574GPIOOutputPin', GPIOOutputPin)
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(pins.PCF8574Component),
+    vol.Optional(CONF_ADDRESS, default=0x21): cv.i2c_address,
+    vol.Optional(CONF_PCF8575, default=False): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_pcf8574_component(config[CONF_ADDRESS], config[CONF_PCF8575])
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_PCF8574'

esphome/components/pn532.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome import automation, pins
+from esphome.components import binary_sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_ON_TAG, CONF_SPI_ID, CONF_TRIGGER_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, Trigger, std_string
+
+DEPENDENCIES = ['spi']
+MULTI_CONF = True
+
+PN532Component = binary_sensor.binary_sensor_ns.class_('PN532Component', PollingComponent,
+                                                       spi.SPIDevice)
+PN532Trigger = binary_sensor.binary_sensor_ns.class_('PN532Trigger', Trigger.template(std_string))
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(PN532Component),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+    vol.Optional(CONF_ON_TAG): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(PN532Trigger),
+    }),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_pn532_component(spi_, cs, config.get(CONF_UPDATE_INTERVAL))
+    pn532 = Pvariable(config[CONF_ID], rhs)
+
+    for conf_ in config.get(CONF_ON_TAG, []):
+        trigger = Pvariable(conf_[CONF_TRIGGER_ID], pn532.make_trigger())
+        automation.build_automations(trigger, [(std_string, 'x')], conf_)
+
+    setup_component(pn532, config)
+
+
+BUILD_FLAGS = '-DUSE_PN532'

esphome/components/power_supply.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+PowerSupplyComponent = esphome_ns.class_('PowerSupplyComponent', Component)
+
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(PowerSupplyComponent),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+
+    rhs = App.make_power_supply(pin)
+    psu = Pvariable(config[CONF_ID], rhs)
+    if CONF_ENABLE_TIME in config:
+        add(psu.set_enable_time(config[CONF_ENABLE_TIME]))
+    if CONF_KEEP_ON_TIME in config:
+        add(psu.set_keep_on_time(config[CONF_KEEP_ON_TIME]))
+
+    setup_component(psu, config)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'

esphome/components/rdm6300.py

@@ -0,0 +1,27 @@
+from esphome.components import binary_sensor, uart
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_UART_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['uart']
+
+RDM6300Component = binary_sensor.binary_sensor_ns.class_('RDM6300Component', Component,
+                                                         uart.UARTDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(RDM6300Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(uart.UARTComponent),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    rhs = App.make_rdm6300_component(uart_)
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_RDM6300'

esphome/components/remote_receiver.py

@@ -0,0 +1,76 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_BUFFER_SIZE, CONF_DUMP, CONF_FILTER, CONF_ID, CONF_IDLE, \
+    CONF_PIN, CONF_TOLERANCE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+from esphome.py_compat import string_types
+
+remote_ns = esphome_ns.namespace('remote')
+MULTI_CONF = True
+
+RemoteControlComponentBase = remote_ns.class_('RemoteControlComponentBase')
+RemoteReceiverComponent = remote_ns.class_('RemoteReceiverComponent',
+                                           RemoteControlComponentBase,
+                                           Component)
+
+RemoteReceiveDumper = remote_ns.class_('RemoteReceiveDumper')
+
+DUMPERS = {
+    'jvc': remote_ns.class_('JVCDumper', RemoteReceiveDumper),
+    'lg': remote_ns.class_('LGDumper', RemoteReceiveDumper),
+    'nec': remote_ns.class_('NECDumper', RemoteReceiveDumper),
+    'panasonic': remote_ns.class_('PanasonicDumper', RemoteReceiveDumper),
+    'raw': remote_ns.class_('RawDumper', RemoteReceiveDumper),
+    'samsung': remote_ns.class_('SamsungDumper', RemoteReceiveDumper),
+    'sony': remote_ns.class_('SonyDumper', RemoteReceiveDumper),
+    'rc_switch': remote_ns.class_('RCSwitchDumper', RemoteReceiveDumper),
+    'rc5': remote_ns.class_('RC5Dumper', RemoteReceiveDumper),
+}
+
+
+def validate_dumpers_all(value):
+    if not isinstance(value, string_types):
+        raise vol.Invalid("Not valid dumpers")
+    if value.upper() == "ALL":
+        return list(sorted(list(DUMPERS)))
+    raise vol.Invalid("Not valid dumpers")
+
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(RemoteReceiverComponent),
+    vol.Required(CONF_PIN): vol.All(pins.internal_gpio_input_pin_schema,
+                                    pins.validate_has_interrupt),
+    vol.Optional(CONF_DUMP, default=[]):
+        vol.Any(validate_dumpers_all, cv.ensure_list(cv.one_of(*DUMPERS, lower=True))),
+    vol.Optional(CONF_TOLERANCE): vol.All(cv.percentage_int, vol.Range(min=0)),
+    vol.Optional(CONF_BUFFER_SIZE): cv.validate_bytes,
+    vol.Optional(CONF_FILTER): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_IDLE): cv.positive_time_period_microseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_remote_receiver_component(pin)
+    receiver = Pvariable(config[CONF_ID], rhs)
+
+    for dumper in config[CONF_DUMP]:
+        add(receiver.add_dumper(DUMPERS[dumper].new()))
+    if CONF_TOLERANCE in config:
+        add(receiver.set_tolerance(config[CONF_TOLERANCE]))
+    if CONF_BUFFER_SIZE in config:
+        add(receiver.set_buffer_size(config[CONF_BUFFER_SIZE]))
+    if CONF_FILTER in config:
+        add(receiver.set_filter_us(config[CONF_FILTER]))
+    if CONF_IDLE in config:
+        add(receiver.set_idle_us(config[CONF_IDLE]))
+
+    setup_component(receiver, config)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_RECEIVER'

esphome/components/remote_transmitter.py

@@ -0,0 +1,120 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components.remote_receiver import RemoteControlComponentBase, remote_ns
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_CARRIER_DUTY_PERCENT, CONF_CHANNEL, CONF_CODE, \
+    CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_ID, CONF_INVERTED, CONF_ONE, CONF_PIN, \
+    CONF_PROTOCOL, CONF_PULSE_LENGTH, CONF_STATE, CONF_SYNC, CONF_ZERO
+from esphome.core import HexInt
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+from esphome.py_compat import text_type
+
+RemoteTransmitterComponent = remote_ns.class_('RemoteTransmitterComponent',
+                                              RemoteControlComponentBase, Component)
+RCSwitchProtocol = remote_ns.class_('RCSwitchProtocol')
+rc_switch_protocols = remote_ns.rc_switch_protocols
+
+MULTI_CONF = True
+
+
+def validate_rc_switch_code(value):
+    if not isinstance(value, (str, text_type)):
+        raise vol.Invalid("All RCSwitch codes must be in quotes ('')")
+    for c in value:
+        if c not in ('0', '1'):
+            raise vol.Invalid(u"Invalid RCSwitch code character '{}'. Only '0' and '1' are allowed"
+                              u"".format(c))
+    if len(value) > 32:
+        raise vol.Invalid("Maximum length for RCSwitch codes is 32, code '{}' has length {}"
+                          "".format(value, len(value)))
+    if not value:
+        raise vol.Invalid("RCSwitch code must not be empty")
+    return value
+
+
+RC_SWITCH_TIMING_SCHEMA = vol.All([cv.uint8_t], vol.Length(min=2, max=2))
+
+RC_SWITCH_PROTOCOL_SCHEMA = vol.Any(
+    vol.All(vol.Coerce(int), vol.Range(min=1, max=7)),
+    cv.Schema({
+        vol.Required(CONF_PULSE_LENGTH): cv.uint32_t,
+        vol.Optional(CONF_SYNC, default=[1, 31]): RC_SWITCH_TIMING_SCHEMA,
+        vol.Optional(CONF_ZERO, default=[1, 3]): RC_SWITCH_TIMING_SCHEMA,
+        vol.Optional(CONF_ONE, default=[3, 1]): RC_SWITCH_TIMING_SCHEMA,
+        vol.Optional(CONF_INVERTED, default=False): cv.boolean,
+    })
+)
+
+RC_SWITCH_RAW_SCHEMA = cv.Schema({
+    vol.Required(CONF_CODE): validate_rc_switch_code,
+    vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
+})
+RC_SWITCH_TYPE_A_SCHEMA = cv.Schema({
+    vol.Required(CONF_GROUP): vol.All(validate_rc_switch_code, vol.Length(min=5, max=5)),
+    vol.Required(CONF_DEVICE): vol.All(validate_rc_switch_code, vol.Length(min=5, max=5)),
+    vol.Required(CONF_STATE): cv.boolean,
+    vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
+})
+RC_SWITCH_TYPE_B_SCHEMA = cv.Schema({
+    vol.Required(CONF_ADDRESS): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
+    vol.Required(CONF_CHANNEL): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
+    vol.Required(CONF_STATE): cv.boolean,
+    vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
+})
+RC_SWITCH_TYPE_C_SCHEMA = cv.Schema({
+    vol.Required(CONF_FAMILY): cv.one_of('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+                                         'l', 'm', 'n', 'o', 'p', lower=True),
+    vol.Required(CONF_GROUP): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
+    vol.Required(CONF_DEVICE): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
+    vol.Required(CONF_STATE): cv.boolean,
+    vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
+})
+RC_SWITCH_TYPE_D_SCHEMA = cv.Schema({
+    vol.Required(CONF_GROUP): cv.one_of('a', 'b', 'c', 'd', lower=True),
+    vol.Required(CONF_DEVICE): vol.All(cv.uint8_t, vol.Range(min=1, max=3)),
+    vol.Required(CONF_STATE): cv.boolean,
+    vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
+})
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(RemoteTransmitterComponent),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_CARRIER_DUTY_PERCENT): vol.All(cv.percentage_int,
+                                                     vol.Range(min=1, max=100)),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def build_rc_switch_protocol(config):
+    if isinstance(config, int):
+        return rc_switch_protocols[config]
+    pl = config[CONF_PULSE_LENGTH]
+    return RCSwitchProtocol(config[CONF_SYNC][0] * pl, config[CONF_SYNC][1] * pl,
+                            config[CONF_ZERO][0] * pl, config[CONF_ZERO][1] * pl,
+                            config[CONF_ONE][0] * pl, config[CONF_ONE][1] * pl,
+                            config[CONF_INVERTED])
+
+
+def binary_code(value):
+    code = 0
+    for val in value:
+        code <<= 1
+        code |= val == '1'
+    return HexInt(code)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_remote_transmitter_component(pin)
+    transmitter = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_CARRIER_DUTY_PERCENT in config:
+        add(transmitter.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))
+
+    setup_component(transmitter, config)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_TRANSMITTER'

esphome/components/script.py

@@ -0,0 +1,52 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_types import Action, Trigger, esphome_ns
+
+Script = esphome_ns.class_('Script', Trigger.template())
+ScriptExecuteAction = esphome_ns.class_('ScriptExecuteAction', Action)
+ScriptStopAction = esphome_ns.class_('ScriptStopAction', Action)
+
+CONFIG_SCHEMA = automation.validate_automation({
+    vol.Required(CONF_ID): cv.declare_variable_id(Script),
+})
+
+
+def to_code(config):
+    for conf in config:
+        trigger = Pvariable(conf[CONF_ID], Script.new())
+        automation.build_automations(trigger, [], conf)
+
+
+CONF_SCRIPT_EXECUTE = 'script.execute'
+SCRIPT_EXECUTE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Script),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SCRIPT_EXECUTE, SCRIPT_EXECUTE_ACTION_SCHEMA)
+def script_execute_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_execute_action(template_arg)
+    type = ScriptExecuteAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SCRIPT_STOP = 'script.stop'
+SCRIPT_STOP_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Script),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SCRIPT_STOP, SCRIPT_STOP_ACTION_SCHEMA)
+def script_stop_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_stop_action(template_arg)
+    type = ScriptStopAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphome/components/sensor/__init__.py

@@ -0,0 +1,298 @@
+import math
+
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import CONDITION_REGISTRY
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
+    CONF_CALIBRATE_LINEAR, CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, \
+    CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_OUT, CONF_FROM, \
+    CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_LAMBDA, CONF_MQTT_ID, \
+    CONF_MULTIPLY, CONF_OFFSET, CONF_ON_RAW_VALUE, CONF_ON_VALUE, CONF_ON_VALUE_RANGE, CONF_OR, \
+    CONF_SEND_EVERY, CONF_SEND_FIRST_AT, CONF_SLIDING_WINDOW_MOVING_AVERAGE, \
+    CONF_THROTTLE, CONF_TO, CONF_TRIGGER_ID, CONF_UNIQUE, CONF_UNIT_OF_MEASUREMENT, \
+    CONF_WINDOW_SIZE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_types import App, Component, Nameable, PollingComponent, Trigger, \
+    esphome_ns, float_, optional
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+
+def validate_recursive_filter(value):
+    return FILTERS_SCHEMA(value)
+
+
+def validate_send_first_at(value):
+    send_first_at = value.get(CONF_SEND_FIRST_AT)
+    send_every = value[CONF_SEND_EVERY]
+    if send_first_at is not None and send_first_at > send_every:
+        raise vol.Invalid("send_first_at must be smaller than or equal to send_every! {} <= {}"
+                          "".format(send_first_at, send_every))
+    return value
+
+
+FILTER_KEYS = [CONF_OFFSET, CONF_MULTIPLY, CONF_FILTER_OUT,
+               CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_LAMBDA,
+               CONF_THROTTLE, CONF_DELTA, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR,
+               CONF_CALIBRATE_LINEAR]
+
+
+def validate_datapoint(value):
+    if isinstance(value, dict):
+        return cv.Schema({
+            vol.Required(CONF_FROM): cv.float_,
+            vol.Required(CONF_TO): cv.float_,
+        })(value)
+    value = cv.string(value)
+    if '->' not in value:
+        raise vol.Invalid("Datapoint mapping must contain '->'")
+    a, b = value.split('->', 1)
+    a, b = a.strip(), b.strip()
+    return validate_datapoint({
+        CONF_FROM: cv.float_(a),
+        CONF_TO: cv.float_(b)
+    })
+
+
+FILTERS_SCHEMA = cv.ensure_list({
+    vol.Optional(CONF_OFFSET): cv.float_,
+    vol.Optional(CONF_MULTIPLY): cv.float_,
+    vol.Optional(CONF_FILTER_OUT): cv.float_,
+    vol.Optional('filter_nan'): cv.invalid("The filter_nan filter has been removed. Please use "
+                                           "'filter_out: nan' instead"),
+    vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.All(cv.Schema({
+        vol.Optional(CONF_WINDOW_SIZE, default=15): cv.positive_not_null_int,
+        vol.Optional(CONF_SEND_EVERY, default=15): cv.positive_not_null_int,
+        vol.Optional(CONF_SEND_FIRST_AT): cv.positive_not_null_int,
+    }), validate_send_first_at),
+    vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): cv.Schema({
+        vol.Optional(CONF_ALPHA, default=0.1): cv.positive_float,
+        vol.Optional(CONF_SEND_EVERY, default=15): cv.positive_not_null_int,
+    }),
+    vol.Optional(CONF_CALIBRATE_LINEAR): vol.All(
+        cv.ensure_list(validate_datapoint), vol.Length(min=2)),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_THROTTLE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DELTA): cv.float_,
+    vol.Optional(CONF_UNIQUE): cv.invalid("The unique filter has been removed in 1.12, please "
+                                          "replace with a delta filter with small value."),
+    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_exactly_one_key(*FILTER_KEYS))
+
+# Base
+sensor_ns = esphome_ns.namespace('sensor')
+Sensor = sensor_ns.class_('Sensor', Nameable)
+SensorPtr = Sensor.operator('ptr')
+MQTTSensorComponent = sensor_ns.class_('MQTTSensorComponent', mqtt.MQTTComponent)
+
+PollingSensorComponent = sensor_ns.class_('PollingSensorComponent', PollingComponent, Sensor)
+EmptySensor = sensor_ns.class_('EmptySensor', Sensor)
+EmptyPollingParentSensor = sensor_ns.class_('EmptyPollingParentSensor', EmptySensor)
+
+# Triggers
+SensorStateTrigger = sensor_ns.class_('SensorStateTrigger', Trigger.template(float_))
+SensorRawStateTrigger = sensor_ns.class_('SensorRawStateTrigger', Trigger.template(float_))
+ValueRangeTrigger = sensor_ns.class_('ValueRangeTrigger', Trigger.template(float_), Component)
+
+# Filters
+Filter = sensor_ns.class_('Filter')
+SlidingWindowMovingAverageFilter = sensor_ns.class_('SlidingWindowMovingAverageFilter', Filter)
+ExponentialMovingAverageFilter = sensor_ns.class_('ExponentialMovingAverageFilter', Filter)
+LambdaFilter = sensor_ns.class_('LambdaFilter', Filter)
+OffsetFilter = sensor_ns.class_('OffsetFilter', Filter)
+MultiplyFilter = sensor_ns.class_('MultiplyFilter', Filter)
+FilterOutValueFilter = sensor_ns.class_('FilterOutValueFilter', Filter)
+ThrottleFilter = sensor_ns.class_('ThrottleFilter', Filter)
+DebounceFilter = sensor_ns.class_('DebounceFilter', Filter, Component)
+HeartbeatFilter = sensor_ns.class_('HeartbeatFilter', Filter, Component)
+DeltaFilter = sensor_ns.class_('DeltaFilter', Filter)
+OrFilter = sensor_ns.class_('OrFilter', Filter)
+CalibrateLinearFilter = sensor_ns.class_('CalibrateLinearFilter', Filter)
+SensorInRangeCondition = sensor_ns.class_('SensorInRangeCondition', Filter)
+
+SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSensorComponent),
+    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.All(cv.requires_component('mqtt'),
+                                             vol.Any(None, cv.positive_time_period_milliseconds)),
+    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
+    vol.Optional(CONF_ON_VALUE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SensorStateTrigger),
+    }),
+    vol.Optional(CONF_ON_RAW_VALUE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SensorRawStateTrigger),
+    }),
+    vol.Optional(CONF_ON_VALUE_RANGE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ValueRangeTrigger),
+        vol.Optional(CONF_ABOVE): cv.float_,
+        vol.Optional(CONF_BELOW): cv.float_,
+    }, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
+})
+
+SENSOR_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SENSOR_SCHEMA.schema)
+
+
+def setup_filter(config):
+    if CONF_OFFSET in config:
+        yield OffsetFilter.new(config[CONF_OFFSET])
+    elif CONF_MULTIPLY in config:
+        yield MultiplyFilter.new(config[CONF_MULTIPLY])
+    elif CONF_FILTER_OUT in config:
+        yield FilterOutValueFilter.new(config[CONF_FILTER_OUT])
+    elif CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
+        conf = config[CONF_SLIDING_WINDOW_MOVING_AVERAGE]
+        yield SlidingWindowMovingAverageFilter.new(conf[CONF_WINDOW_SIZE], conf[CONF_SEND_EVERY],
+                                                   conf.get(CONF_SEND_FIRST_AT))
+    elif CONF_EXPONENTIAL_MOVING_AVERAGE in config:
+        conf = config[CONF_EXPONENTIAL_MOVING_AVERAGE]
+        yield ExponentialMovingAverageFilter.new(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
+    elif CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(float_, 'x')],
+                                      return_type=optional.template(float_)):
+            yield None
+        yield LambdaFilter.new(lambda_)
+    elif CONF_THROTTLE in config:
+        yield ThrottleFilter.new(config[CONF_THROTTLE])
+    elif CONF_DELTA in config:
+        yield DeltaFilter.new(config[CONF_DELTA])
+    elif CONF_OR in config:
+        for filters in setup_filters(config[CONF_OR]):
+            yield None
+        yield OrFilter.new(filters)
+    elif CONF_HEARTBEAT in config:
+        yield App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
+    elif CONF_DEBOUNCE in config:
+        yield App.register_component(DebounceFilter.new(config[CONF_DEBOUNCE]))
+    elif CONF_CALIBRATE_LINEAR in config:
+        x = [conf[CONF_FROM] for conf in config[CONF_CALIBRATE_LINEAR]]
+        y = [conf[CONF_TO] for conf in config[CONF_CALIBRATE_LINEAR]]
+        k, b = fit_linear(x, y)
+        yield CalibrateLinearFilter.new(k, b)
+
+
+def setup_filters(config):
+    filters = []
+    for conf in config:
+        for filter in setup_filter(conf):
+            yield None
+        filters.append(filter)
+    yield filters
+
+
+def setup_sensor_core_(sensor_var, config):
+    if CONF_INTERNAL in config:
+        add(sensor_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        add(sensor_var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+    if CONF_ICON in config:
+        add(sensor_var.set_icon(config[CONF_ICON]))
+    if CONF_ACCURACY_DECIMALS in config:
+        add(sensor_var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_FILTERS in config:
+        for filters in setup_filters(config[CONF_FILTERS]):
+            yield
+        add(sensor_var.set_filters(filters))
+
+    for conf in config.get(CONF_ON_VALUE, []):
+        rhs = sensor_var.make_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(float_, 'x')], conf)
+    for conf in config.get(CONF_ON_RAW_VALUE, []):
+        rhs = sensor_var.make_raw_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(float_, 'x')], conf)
+    for conf in config.get(CONF_ON_VALUE_RANGE, []):
+        rhs = sensor_var.make_value_range_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        add(App.register_component(trigger))
+        if CONF_ABOVE in conf:
+            for template_ in templatable(conf[CONF_ABOVE], float_, float_):
+                yield
+            add(trigger.set_min(template_))
+        if CONF_BELOW in conf:
+            for template_ in templatable(conf[CONF_BELOW], float_, float_):
+                yield
+            add(trigger.set_max(template_))
+        automation.build_automations(trigger, [(float_, 'x')], conf)
+
+    mqtt_ = sensor_var.Pget_mqtt()
+    if CONF_EXPIRE_AFTER in config:
+        if config[CONF_EXPIRE_AFTER] is None:
+            add(mqtt_.disable_expire_after())
+        else:
+            add(mqtt_.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    setup_mqtt_component(mqtt_, config)
+
+
+def setup_sensor(sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        sensor_obj = Pvariable(config[CONF_ID], sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_sensor_core_, sensor_obj, config)
+
+
+def register_sensor(var, config):
+    sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_sensor(sensor_var))
+    CORE.add_job(setup_sensor_core_, sensor_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SENSOR'
+
+CONF_SENSOR_IN_RANGE = 'sensor.in_range'
+SENSOR_IN_RANGE_CONDITION_SCHEMA = vol.All({
+    vol.Required(CONF_ID): cv.use_variable_id(Sensor),
+    vol.Optional(CONF_ABOVE): cv.float_,
+    vol.Optional(CONF_BELOW): cv.float_,
+}, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
+
+
+@CONDITION_REGISTRY.register(CONF_SENSOR_IN_RANGE, SENSOR_IN_RANGE_CONDITION_SCHEMA)
+def sensor_in_range_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_sensor_in_range_condition(template_arg)
+    type = SensorInRangeCondition.template(template_arg)
+    cond = Pvariable(condition_id, rhs, type=type)
+
+    if CONF_ABOVE in config:
+        add(cond.set_min(config[CONF_ABOVE]))
+    if CONF_BELOW in config:
+        add(cond.set_max(config[CONF_BELOW]))
+
+    yield cond
+
+
+def _mean(xs):
+    return sum(xs) / len(xs)
+
+
+def _std(x):
+    return math.sqrt(sum((x_ - _mean(x))**2 for x_ in x) / (len(x) - 1))
+
+
+def _correlation_coeff(x, y):
+    m_x, m_y = _mean(x), _mean(y)
+    s_xy = sum((x_ - m_x) * (y_ - m_y) for x_, y_ in zip(x, y))
+    s_sq_x = sum((x_ - m_x)**2 for x_ in x)
+    s_sq_y = sum((y_ - m_y)**2 for y_ in y)
+    return s_xy / math.sqrt(s_sq_x * s_sq_y)
+
+
+def fit_linear(x, y):
+    assert len(x) == len(y)
+    m_x, m_y = _mean(x), _mean(y)
+    r = _correlation_coeff(x, y)
+    k = r * (_std(y) / _std(x))
+    b = m_y - k * m_x
+    return k, b

esphome/components/sensor/adc.py

@@ -0,0 +1,62 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, global_ns
+
+ATTENUATION_MODES = {
+    '0db': global_ns.ADC_0db,
+    '2.5db': global_ns.ADC_2_5db,
+    '6db': global_ns.ADC_6db,
+    '11db': global_ns.ADC_11db,
+}
+
+
+def validate_adc_pin(value):
+    vcc = str(value).upper()
+    if vcc == 'VCC':
+        return cv.only_on_esp8266(vcc)
+    return pins.analog_pin(value)
+
+
+ADCSensorComponent = sensor.sensor_ns.class_('ADCSensorComponent', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ADCSensorComponent),
+    vol.Required(CONF_PIN): validate_adc_pin,
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES,
+                                                                        lower=True)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    pin = config[CONF_PIN]
+    if pin == 'VCC':
+        pin = 0
+    rhs = App.make_adc_sensor(config[CONF_NAME], pin,
+                              config.get(CONF_UPDATE_INTERVAL))
+    adc = Pvariable(config[CONF_ID], rhs)
+    if CONF_ATTENUATION in config:
+        add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
+    sensor.setup_sensor(adc, config)
+    setup_component(adc, config)
+
+
+BUILD_FLAGS = '-DUSE_ADC_SENSOR'
+
+
+def required_build_flags(config):
+    if config[CONF_PIN] == 'VCC':
+        return '-DUSE_ADC_SENSOR_VCC'
+    return None
+
+
+def includes(config):
+    if config[CONF_PIN] == 'VCC':
+        return 'ADC_MODE(ADC_VCC);'
+    return None

esphome/components/sensor/ads1115.py

@@ -0,0 +1,72 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.ads1115 import ADS1115Component
+import esphome.config_validation as cv
+from esphome.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import get_variable
+from esphome.py_compat import string_types
+
+DEPENDENCIES = ['ads1115']
+
+ADS1115Multiplexer = sensor.sensor_ns.enum('ADS1115Multiplexer')
+MUX = {
+    'A0_A1': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N1,
+    'A0_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N3,
+    'A1_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_N3,
+    'A2_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_N3,
+    'A0_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_NG,
+    'A1_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_NG,
+    'A2_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_NG,
+    'A3_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P3_NG,
+}
+
+ADS1115Gain = sensor.sensor_ns.enum('ADS1115Gain')
+GAIN = {
+    '6.144': ADS1115Gain.ADS1115_GAIN_6P144,
+    '4.096': ADS1115Gain.ADS1115_GAIN_4P096,
+    '2.048': ADS1115Gain.ADS1115_GAIN_2P048,
+    '1.024': ADS1115Gain.ADS1115_GAIN_1P024,
+    '0.512': ADS1115Gain.ADS1115_GAIN_0P512,
+    '0.256': ADS1115Gain.ADS1115_GAIN_0P256,
+}
+
+
+def validate_gain(value):
+    if isinstance(value, float):
+        value = u'{:0.03f}'.format(value)
+    elif not isinstance(value, string_types):
+        raise vol.Invalid('invalid gain "{}"'.format(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)
+
+
+ADS1115Sensor = sensor.sensor_ns.class_('ADS1115Sensor', sensor.EmptySensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ADS1115Sensor),
+    vol.Required(CONF_MULTIPLEXER): validate_mux,
+    vol.Required(CONF_GAIN): validate_gain,
+    cv.GenerateID(CONF_ADS1115_ID): cv.use_variable_id(ADS1115Component),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ADS1115_ID]):
+        yield
+
+    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'

esphome/components/sensor/apds9960.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.apds9960 import APDS9960, CONF_APDS9960_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_TYPE
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['apds9960']
+
+TYPES = {
+    'CLEAR': 'make_clear_channel',
+    'RED': 'make_red_channel',
+    'GREEN': 'make_green_channel',
+    'BLUE': 'make_blue_channel',
+    'PROXIMITY': 'make_proximity',
+}
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
+    vol.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
+    cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_APDS9960_ID]):
+        yield
+    func = getattr(hub, TYPES[config[CONF_TYPE]])
+    rhs = func(config[CONF_NAME])
+    sensor.register_sensor(rhs, config)

esphome/components/sensor/bh1750.py

@@ -0,0 +1,41 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['i2c']
+
+BH1750Resolution = sensor.sensor_ns.enum('BH1750Resolution')
+BH1750_RESOLUTIONS = {
+    4.0: BH1750Resolution.BH1750_RESOLUTION_4P0_LX,
+    1.0: BH1750Resolution.BH1750_RESOLUTION_1P0_LX,
+    0.5: BH1750Resolution.BH1750_RESOLUTION_0P5_LX,
+}
+
+BH1750Sensor = sensor.sensor_ns.class_('BH1750Sensor', sensor.PollingSensorComponent,
+                                       i2c.I2CDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BH1750Sensor),
+    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.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_bh1750_sensor(config[CONF_NAME], config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bh1750 = Pvariable(config[CONF_ID], rhs)
+    if CONF_RESOLUTION in config:
+        add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
+    sensor.setup_sensor(bh1750, config)
+    setup_component(bh1750, config)
+
+
+BUILD_FLAGS = '-DUSE_BH1750'

esphome/components/sensor/ble_rssi.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import esphome_ns
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+ESP32BLERSSISensor = esphome_ns.class_('ESP32BLERSSISensor', sensor.Sensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLERSSISensor),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_rssi_sensor(config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
+    sensor.register_sensor(rhs, config)

esphome/components/sensor/bme280.py

@@ -0,0 +1,87 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_NAME, \
+    CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BME280Oversampling = sensor.sensor_ns.enum('BME280Oversampling')
+OVERSAMPLING_OPTIONS = {
+    'NONE': BME280Oversampling.BME280_OVERSAMPLING_NONE,
+    '1X': BME280Oversampling.BME280_OVERSAMPLING_1X,
+    '2X': BME280Oversampling.BME280_OVERSAMPLING_2X,
+    '4X': BME280Oversampling.BME280_OVERSAMPLING_4X,
+    '8X': BME280Oversampling.BME280_OVERSAMPLING_8X,
+    '16X': BME280Oversampling.BME280_OVERSAMPLING_16X,
+}
+
+BME280IIRFilter = sensor.sensor_ns.enum('BME280IIRFilter')
+IIR_FILTER_OPTIONS = {
+    'OFF': BME280IIRFilter.BME280_IIR_FILTER_OFF,
+    '2X': BME280IIRFilter.BME280_IIR_FILTER_2X,
+    '4X': BME280IIRFilter.BME280_IIR_FILTER_4X,
+    '8X': BME280IIRFilter.BME280_IIR_FILTER_8X,
+    '16X': BME280IIRFilter.BME280_IIR_FILTER_16X,
+}
+
+BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
+})
+
+BME280Component = sensor.sensor_ns.class_('BME280Component', PollingComponent, i2c.I2CDevice)
+BME280TemperatureSensor = sensor.sensor_ns.class_('BME280TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BME280PressureSensor = sensor.sensor_ns.class_('BME280PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+BME280HumiditySensor = sensor.sensor_ns.class_('BME280HumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BME280Component),
+    vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME280TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME280PressureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME280HumiditySensor),
+    })),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+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))
+    bme280 = Pvariable(config[CONF_ID], rhs)
+    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(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme280.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    sensor.setup_sensor(bme280.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(bme280, config)
+
+
+BUILD_FLAGS = '-DUSE_BME280'

esphome/components/sensor/bme680.py

@@ -0,0 +1,110 @@
+import voluptuous as vol
+
+from esphome import core
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DURATION, CONF_GAS_RESISTANCE, CONF_HEATER, \
+    CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BME680Oversampling = sensor.sensor_ns.enum('BME680Oversampling')
+OVERSAMPLING_OPTIONS = {
+    'NONE': BME680Oversampling.BME680_OVERSAMPLING_NONE,
+    '1X': BME680Oversampling.BME680_OVERSAMPLING_1X,
+    '2X': BME680Oversampling.BME680_OVERSAMPLING_2X,
+    '4X': BME680Oversampling.BME680_OVERSAMPLING_4X,
+    '8X': BME680Oversampling.BME680_OVERSAMPLING_8X,
+    '16X': BME680Oversampling.BME680_OVERSAMPLING_16X,
+}
+
+BME680IIRFilter = sensor.sensor_ns.enum('BME680IIRFilter')
+IIR_FILTER_OPTIONS = {
+    'OFF': BME680IIRFilter.BME680_IIR_FILTER_OFF,
+    '1X': BME680IIRFilter.BME680_IIR_FILTER_1X,
+    '3X': BME680IIRFilter.BME680_IIR_FILTER_3X,
+    '7X': BME680IIRFilter.BME680_IIR_FILTER_7X,
+    '15X': BME680IIRFilter.BME680_IIR_FILTER_15X,
+    '31X': BME680IIRFilter.BME680_IIR_FILTER_31X,
+    '63X': BME680IIRFilter.BME680_IIR_FILTER_63X,
+    '127X': BME680IIRFilter.BME680_IIR_FILTER_127X,
+}
+
+BME680_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
+})
+
+BME680Component = sensor.sensor_ns.class_('BME680Component', PollingComponent, i2c.I2CDevice)
+BME680TemperatureSensor = sensor.sensor_ns.class_('BME680TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BME680PressureSensor = sensor.sensor_ns.class_('BME680PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+BME680HumiditySensor = sensor.sensor_ns.class_('BME680HumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+BME680GasResistanceSensor = sensor.sensor_ns.class_('BME680GasResistanceSensor',
+                                                    sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BME680Component),
+    vol.Optional(CONF_ADDRESS, default=0x76): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680PressureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680HumiditySensor),
+    })),
+    vol.Required(CONF_GAS_RESISTANCE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680GasResistanceSensor),
+    })),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_HEATER): vol.Any(None, vol.All(cv.Schema({
+        vol.Optional(CONF_TEMPERATURE, default=320): vol.All(vol.Coerce(int), vol.Range(200, 400)),
+        vol.Optional(CONF_DURATION, default='150ms'): vol.All(
+            cv.positive_time_period_milliseconds, vol.Range(max=core.TimePeriod(milliseconds=4032)))
+    }, cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION)))),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+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))
+    bme680 = Pvariable(config[CONF_ID], rhs)
+    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))
+    if CONF_HEATER in config:
+        conf = config[CONF_HEATER]
+        if not conf:
+            add(bme680.set_heater(0, 0))
+        else:
+            add(bme680.set_heater(conf[CONF_TEMPERATURE], conf[CONF_DURATION]))
+
+    sensor.setup_sensor(bme680.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme680.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    sensor.setup_sensor(bme680.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    sensor.setup_sensor(bme680.Pget_gas_resistance_sensor(), config[CONF_GAS_RESISTANCE])
+    setup_component(bme680, config)
+
+
+BUILD_FLAGS = '-DUSE_BME680'

esphome/components/sensor/bmp085.py

@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_PRESSURE, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import HexIntLiteral, Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BMP085Component = sensor.sensor_ns.class_('BMP085Component', PollingComponent, i2c.I2CDevice)
+BMP085TemperatureSensor = sensor.sensor_ns.class_('BMP085TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BMP085PressureSensor = sensor.sensor_ns.class_('BMP085PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BMP085Component),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP085TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP085PressureSensor),
+    })),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+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 = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(bmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
+
+    sensor.setup_sensor(bmp.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(bmp, config)
+
+
+BUILD_FLAGS = '-DUSE_BMP085_SENSOR'

esphome/components/sensor/bmp280.py

@@ -0,0 +1,77 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_IIR_FILTER, CONF_NAME, \
+    CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BMP280Oversampling = sensor.sensor_ns.enum('BMP280Oversampling')
+OVERSAMPLING_OPTIONS = {
+    'NONE': BMP280Oversampling.BMP280_OVERSAMPLING_NONE,
+    '1X': BMP280Oversampling.BMP280_OVERSAMPLING_1X,
+    '2X': BMP280Oversampling.BMP280_OVERSAMPLING_2X,
+    '4X': BMP280Oversampling.BMP280_OVERSAMPLING_4X,
+    '8X': BMP280Oversampling.BMP280_OVERSAMPLING_8X,
+    '16X': BMP280Oversampling.BMP280_OVERSAMPLING_16X,
+}
+
+BMP280IIRFilter = sensor.sensor_ns.enum('BMP280IIRFilter')
+IIR_FILTER_OPTIONS = {
+    'OFF': BMP280IIRFilter.BMP280_IIR_FILTER_OFF,
+    '2X': BMP280IIRFilter.BMP280_IIR_FILTER_2X,
+    '4X': BMP280IIRFilter.BMP280_IIR_FILTER_4X,
+    '8X': BMP280IIRFilter.BMP280_IIR_FILTER_8X,
+    '16X': BMP280IIRFilter.BMP280_IIR_FILTER_16X,
+}
+
+BMP280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
+})
+
+BMP280Component = sensor.sensor_ns.class_('BMP280Component', PollingComponent, i2c.I2CDevice)
+BMP280TemperatureSensor = sensor.sensor_ns.class_('BMP280TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BMP280PressureSensor = sensor.sensor_ns.class_('BMP280PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BMP280Component),
+    vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP280TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP280PressureSensor),
+    })),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_bmp280_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bmp280 = Pvariable(config[CONF_ID], rhs)
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bmp280.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bmp280.set_pressure_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bmp280.set_iir_filter(constant))
+
+    sensor.setup_sensor(bmp280.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp280.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(bmp280, config)
+
+
+BUILD_FLAGS = '-DUSE_BMP280'

esphome/components/sensor/cse7766.py

@@ -0,0 +1,59 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CURRENT, CONF_ID, CONF_NAME, CONF_POWER, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL, CONF_VOLTAGE
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['uart']
+
+CSE7766Component = sensor.sensor_ns.class_('CSE7766Component', PollingComponent, uart.UARTDevice)
+CSE7766VoltageSensor = sensor.sensor_ns.class_('CSE7766VoltageSensor',
+                                               sensor.EmptySensor)
+CSE7766CurrentSensor = sensor.sensor_ns.class_('CSE7766CurrentSensor',
+                                               sensor.EmptySensor)
+CSE7766PowerSensor = sensor.sensor_ns.class_('CSE7766PowerSensor',
+                                             sensor.EmptySensor)
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CSE7766Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+
+    vol.Optional(CONF_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(CSE7766VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(CSE7766CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(CSE7766PowerSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
+                                                               CONF_POWER))
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+
+    rhs = App.make_cse7766(uart_, config.get(CONF_UPDATE_INTERVAL))
+    cse = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_VOLTAGE in config:
+        conf = config[CONF_VOLTAGE]
+        sensor.register_sensor(cse.make_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT in config:
+        conf = config[CONF_CURRENT]
+        sensor.register_sensor(cse.make_current_sensor(conf[CONF_NAME]), conf)
+    if CONF_POWER in config:
+        conf = config[CONF_POWER]
+        sensor.register_sensor(cse.make_power_sensor(conf[CONF_NAME]), conf)
+    setup_component(cse, config)
+
+
+BUILD_FLAGS = '-DUSE_CSE7766'

esphome/components/sensor/custom.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_SENSORS
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomSensorConstructor = sensor.sensor_ns.class_('CustomSensorConstructor')
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomSensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_SENSORS): cv.ensure_list(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
+    })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(sensor.SensorPtr)):
+        yield
+
+    rhs = CustomSensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_SENSORS]):
+        rhs = custom.Pget_sensor(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        sensor.register_sensor(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_SENSOR'

esphome/components/sensor/dallas.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.dallas import DallasComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
+    CONF_RESOLUTION
+from esphome.cpp_generator import HexIntLiteral, get_variable
+
+DallasTemperatureSensor = sensor.sensor_ns.class_('DallasTemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DallasTemperatureSensor),
+    vol.Exclusive(CONF_ADDRESS, 'dallas'): cv.hex_int,
+    vol.Exclusive(CONF_INDEX, 'dallas'): cv.positive_int,
+    cv.GenerateID(CONF_DALLAS_ID): cv.use_variable_id(DallasComponent),
+    vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=9, max=12)),
+}), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_DALLAS_ID]):
+        yield
+    if CONF_ADDRESS in config:
+        address = HexIntLiteral(config[CONF_ADDRESS])
+        rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address, config.get(CONF_RESOLUTION))
+    else:
+        rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
+                                       config.get(CONF_RESOLUTION))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphome/components/sensor/dht.py

@@ -0,0 +1,59 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, \
+    CONF_PIN, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent
+from esphome.pins import gpio_input_pullup_pin_schema
+
+DHTModel = sensor.sensor_ns.enum('DHTModel')
+DHT_MODELS = {
+    'AUTO_DETECT': DHTModel.DHT_MODEL_AUTO_DETECT,
+    'DHT11': DHTModel.DHT_MODEL_DHT11,
+    'DHT22': DHTModel.DHT_MODEL_DHT22,
+    'AM2302': DHTModel.DHT_MODEL_AM2302,
+    'RHT03': DHTModel.DHT_MODEL_RHT03,
+    'SI7021': DHTModel.DHT_MODEL_SI7021,
+}
+
+DHTComponent = sensor.sensor_ns.class_('DHTComponent', PollingComponent)
+DHTTemperatureSensor = sensor.sensor_ns.class_('DHTTemperatureSensor',
+                                               sensor.EmptyPollingParentSensor)
+DHTHumiditySensor = sensor.sensor_ns.class_('DHTHumiditySensor',
+                                            sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DHTComponent),
+    vol.Required(CONF_PIN): gpio_input_pullup_pin_schema,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHTTemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHTHumiditySensor),
+    })),
+    vol.Optional(CONF_MODEL): cv.one_of(*DHT_MODELS, upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_dht_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                              config[CONF_HUMIDITY][CONF_NAME],
+                              pin, config.get(CONF_UPDATE_INTERVAL))
+    dht = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_MODEL in config:
+        constant = DHT_MODELS[config[CONF_MODEL]]
+        add(dht.set_dht_model(constant))
+
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(dht, config)
+
+
+BUILD_FLAGS = '-DUSE_DHT_SENSOR'

esphome/components/sensor/dht12.py

@@ -0,0 +1,42 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+DHT12Component = sensor.sensor_ns.class_('DHT12Component', PollingComponent, i2c.I2CDevice)
+DHT12TemperatureSensor = sensor.sensor_ns.class_('DHT12TemperatureSensor',
+                                                 sensor.EmptyPollingParentSensor)
+DHT12HumiditySensor = sensor.sensor_ns.class_('DHT12HumiditySensor',
+                                              sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DHT12Component),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHT12TemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHT12HumiditySensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+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 = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(dht, config)
+
+
+BUILD_FLAGS = '-DUSE_DHT12_SENSOR'

esphome/components/sensor/duty_cycle.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App
+
+DutyCycleSensor = sensor.sensor_ns.class_('DutyCycleSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DutyCycleSensor),
+    vol.Required(CONF_PIN): vol.All(pins.internal_gpio_input_pin_schema,
+                                    pins.validate_has_interrupt),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_duty_cycle_sensor(config[CONF_NAME], pin,
+                                     config.get(CONF_UPDATE_INTERVAL))
+    duty = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(duty, config)
+    setup_component(duty, config)
+
+
+BUILD_FLAGS = '-DUSE_DUTY_CYCLE_SENSOR'

esphome/components/sensor/esp32_hall.py

@@ -0,0 +1,28 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+MakeESP32HallSensor = Application.struct('MakeESP32HallSensor')
+ESP32HallSensor = sensor.sensor_ns.class_('ESP32HallSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ESP32HallSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_esp32_hall_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    hall = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(hall, config)
+    setup_component(hall, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_HALL_SENSOR'

esphome/components/sensor/hdc1080.py

@@ -0,0 +1,42 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+HDC1080Component = sensor.sensor_ns.class_('HDC1080Component', PollingComponent, i2c.I2CDevice)
+HDC1080TemperatureSensor = sensor.sensor_ns.class_('HDC1080TemperatureSensor',
+                                                   sensor.EmptyPollingParentSensor)
+HDC1080HumiditySensor = sensor.sensor_ns.class_('HDC1080HumiditySensor',
+                                                sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HDC1080Component),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HDC1080TemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HDC1080HumiditySensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+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 = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(hdc1080.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(hdc1080.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(hdc1080, config)
+
+
+BUILD_FLAGS = '-DUSE_HDC1080_SENSOR'

esphome/components/sensor/hlw8012.py

@@ -0,0 +1,68 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_CF1_PIN, CONF_CF_PIN, CONF_CHANGE_MODE_EVERY, CONF_CURRENT, \
+    CONF_CURRENT_RESISTOR, CONF_ID, CONF_NAME, CONF_POWER, CONF_SEL_PIN, CONF_UPDATE_INTERVAL, \
+    CONF_VOLTAGE, CONF_VOLTAGE_DIVIDER
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent
+
+HLW8012Component = sensor.sensor_ns.class_('HLW8012Component', PollingComponent)
+HLW8012VoltageSensor = sensor.sensor_ns.class_('HLW8012VoltageSensor', sensor.EmptySensor)
+HLW8012CurrentSensor = sensor.sensor_ns.class_('HLW8012CurrentSensor', sensor.EmptySensor)
+HLW8012PowerSensor = sensor.sensor_ns.class_('HLW8012PowerSensor', sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HLW8012Component),
+    vol.Required(CONF_SEL_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_CF_PIN): pins.input_pin,
+    vol.Required(CONF_CF1_PIN): pins.input_pin,
+
+    vol.Optional(CONF_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HLW8012VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HLW8012CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HLW8012PowerSensor),
+    })),
+
+    vol.Optional(CONF_CURRENT_RESISTOR): cv.resistance,
+    vol.Optional(CONF_VOLTAGE_DIVIDER): cv.positive_float,
+    vol.Optional(CONF_CHANGE_MODE_EVERY): vol.All(cv.uint32_t, vol.Range(min=1)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
+                                                               CONF_POWER))
+
+
+def to_code(config):
+    for sel in gpio_output_pin_expression(config[CONF_SEL_PIN]):
+        yield
+
+    rhs = App.make_hlw8012(sel, config[CONF_CF_PIN], config[CONF_CF1_PIN],
+                           config.get(CONF_UPDATE_INTERVAL))
+    hlw = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_VOLTAGE in config:
+        conf = config[CONF_VOLTAGE]
+        sensor.register_sensor(hlw.make_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT in config:
+        conf = config[CONF_CURRENT]
+        sensor.register_sensor(hlw.make_current_sensor(conf[CONF_NAME]), conf)
+    if CONF_POWER in config:
+        conf = config[CONF_POWER]
+        sensor.register_sensor(hlw.make_power_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT_RESISTOR in config:
+        add(hlw.set_current_resistor(config[CONF_CURRENT_RESISTOR]))
+    if CONF_VOLTAGE_DIVIDER in config:
+        add(hlw.set_voltage_divider(config[CONF_VOLTAGE_DIVIDER]))
+    if CONF_CHANGE_MODE_EVERY in config:
+        add(hlw.set_change_mode_every(config[CONF_CHANGE_MODE_EVERY]))
+    setup_component(hlw, config)
+
+
+BUILD_FLAGS = '-DUSE_HLW8012'

esphome/components/sensor/hmc5883l.py

@@ -0,0 +1,89 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_RANGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_FIELD_STRENGTH_X = 'field_strength_x'
+CONF_FIELD_STRENGTH_Y = 'field_strength_y'
+CONF_FIELD_STRENGTH_Z = 'field_strength_z'
+CONF_HEADING = 'heading'
+
+HMC5883LComponent = sensor.sensor_ns.class_('HMC5883LComponent', PollingComponent, i2c.I2CDevice)
+HMC5883LFieldStrengthSensor = sensor.sensor_ns.class_('HMC5883LFieldStrengthSensor',
+                                                      sensor.EmptyPollingParentSensor)
+HMC5883LHeadingSensor = sensor.sensor_ns.class_('HMC5883LHeadingSensor',
+                                                sensor.EmptyPollingParentSensor)
+
+HMC5883LRange = sensor.sensor_ns.enum('HMC5883LRange')
+HMC5883L_RANGES = {
+    88: HMC5883LRange.HMC5883L_RANGE_88_UT,
+    130: HMC5883LRange.HMC5883L_RANGE_130_UT,
+    190: HMC5883LRange.HMC5883L_RANGE_190_UT,
+    250: HMC5883LRange.HMC5883L_RANGE_250_UT,
+    400: HMC5883LRange.HMC5883L_RANGE_400_UT,
+    470: HMC5883LRange.HMC5883L_RANGE_470_UT,
+    560: HMC5883LRange.HMC5883L_RANGE_560_UT,
+    810: HMC5883LRange.HMC5883L_RANGE_810_UT,
+}
+
+
+def validate_range(value):
+    value = cv.string(value)
+    if value.endswith(u'µT') or value.endswith('uT'):
+        value = value[:-2]
+    return cv.one_of(*HMC5883L_RANGES, int=True)(value)
+
+
+SENSOR_KEYS = [CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z,
+               CONF_HEADING]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HMC5883LComponent),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_FIELD_STRENGTH_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LFieldStrengthSensor),
+    })),
+    vol.Optional(CONF_FIELD_STRENGTH_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LFieldStrengthSensor),
+    })),
+    vol.Optional(CONF_FIELD_STRENGTH_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LFieldStrengthSensor),
+    })),
+    vol.Optional(CONF_HEADING): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LHeadingSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+    vol.Optional(CONF_RANGE): validate_range,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_hmc5883l(config.get(CONF_UPDATE_INTERVAL))
+    hmc = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(hmc.set_address(config[CONF_ADDRESS]))
+    if CONF_RANGE in config:
+        add(hmc.set_range(HMC5883L_RANGES[config[CONF_RANGE]]))
+    if CONF_FIELD_STRENGTH_X in config:
+        conf = config[CONF_FIELD_STRENGTH_X]
+        sensor.register_sensor(hmc.Pmake_x_sensor(conf[CONF_NAME]), conf)
+    if CONF_FIELD_STRENGTH_Y in config:
+        conf = config[CONF_FIELD_STRENGTH_Y]
+        sensor.register_sensor(hmc.Pmake_y_sensor(conf[CONF_NAME]), conf)
+    if CONF_FIELD_STRENGTH_Z in config:
+        conf = config[CONF_FIELD_STRENGTH_Z]
+        sensor.register_sensor(hmc.Pmake_z_sensor(conf[CONF_NAME]), conf)
+    if CONF_HEADING in config:
+        conf = config[CONF_HEADING]
+        sensor.register_sensor(hmc.Pmake_heading_sensor(conf[CONF_NAME]), conf)
+    setup_component(hmc, config)
+
+
+BUILD_FLAGS = '-DUSE_HMC5883L'

esphome/components/sensor/homeassistant.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeassistantSensor = sensor.sensor_ns.class_('HomeassistantSensor', sensor.Sensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantSensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    subs = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_SENSOR'

esphome/components/sensor/htu21d.py

@@ -0,0 +1,43 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+MakeHTU21DSensor = Application.struct('MakeHTU21DSensor')
+HTU21DComponent = sensor.sensor_ns.class_('HTU21DComponent', PollingComponent, i2c.I2CDevice)
+HTU21DTemperatureSensor = sensor.sensor_ns.class_('HTU21DTemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+HTU21DHumiditySensor = sensor.sensor_ns.class_('HTU21DHumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HTU21DComponent),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HTU21DTemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HTU21DHumiditySensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+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 = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(htu21d.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(htu21d.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(htu21d, config)
+
+
+BUILD_FLAGS = '-DUSE_HTU21D_SENSOR'

esphome/components/sensor/hx711.py

@@ -0,0 +1,49 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_CLK_PIN, CONF_GAIN, CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Application
+
+MakeHX711Sensor = Application.struct('MakeHX711Sensor')
+HX711Sensor = sensor.sensor_ns.class_('HX711Sensor', sensor.PollingSensorComponent)
+
+CONF_DOUT_PIN = 'dout_pin'
+
+HX711Gain = sensor.sensor_ns.enum('HX711Gain')
+GAINS = {
+    128: HX711Gain.HX711_GAIN_128,
+    32: HX711Gain.HX711_GAIN_32,
+    64: HX711Gain.HX711_GAIN_64,
+}
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HX711Sensor),
+    vol.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema,
+    vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_GAIN): cv.one_of(*GAINS, int=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for dout_pin in gpio_input_pin_expression(config[CONF_DOUT_PIN]):
+        yield
+    for sck_pin in gpio_input_pin_expression(config[CONF_CLK_PIN]):
+        yield
+
+    rhs = App.make_hx711_sensor(config[CONF_NAME], dout_pin, sck_pin,
+                                config.get(CONF_UPDATE_INTERVAL))
+    hx711 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_GAIN in config:
+        add(hx711.set_gain(GAINS[config[CONF_GAIN]]))
+
+    sensor.setup_sensor(hx711, config)
+    setup_component(hx711, config)
+
+
+BUILD_FLAGS = '-DUSE_HX711'

esphome/components/sensor/ina219.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, \
+    CONF_MAX_CURRENT, CONF_MAX_VOLTAGE, CONF_NAME, CONF_POWER, CONF_SHUNT_RESISTANCE, \
+    CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+INA219Component = sensor.sensor_ns.class_('INA219Component', PollingComponent, i2c.I2CDevice)
+INA219VoltageSensor = sensor.sensor_ns.class_('INA219VoltageSensor',
+                                              sensor.EmptyPollingParentSensor)
+INA219CurrentSensor = sensor.sensor_ns.class_('INA219CurrentSensor',
+                                              sensor.EmptyPollingParentSensor)
+INA219PowerSensor = sensor.sensor_ns.class_('INA219PowerSensor', sensor.EmptyPollingParentSensor)
+
+SENSOR_KEYS = [CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT,
+               CONF_POWER]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(INA219Component),
+    vol.Optional(CONF_ADDRESS, default=0x40): cv.i2c_address,
+    vol.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219VoltageSensor),
+    })),
+    vol.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219PowerSensor),
+    })),
+    vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1): vol.All(cv.resistance,
+                                                              vol.Range(min=0.0, max=32.0)),
+    vol.Optional(CONF_MAX_VOLTAGE, default=32.0): vol.All(cv.voltage, vol.Range(min=0.0, max=32.0)),
+    vol.Optional(CONF_MAX_CURRENT, default=3.2): vol.All(cv.current, vol.Range(min=0.0)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_ina219(config[CONF_SHUNT_RESISTANCE],
+                          config[CONF_MAX_CURRENT], config[CONF_MAX_VOLTAGE],
+                          config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    ina = Pvariable(config[CONF_ID], rhs)
+    if CONF_BUS_VOLTAGE in config:
+        conf = config[CONF_BUS_VOLTAGE]
+        sensor.register_sensor(ina.Pmake_bus_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_SHUNT_VOLTAGE in config:
+        conf = config[CONF_SHUNT_VOLTAGE]
+        sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT in config:
+        conf = config[CONF_CURRENT]
+        sensor.register_sensor(ina.Pmake_current_sensor(conf[CONF_NAME]), conf)
+    if CONF_POWER in config:
+        conf = config[CONF_POWER]
+        sensor.register_sensor(ina.Pmake_power_sensor(conf[CONF_NAME]), conf)
+    setup_component(ina, config)
+
+
+BUILD_FLAGS = '-DUSE_INA219'

esphome/components/sensor/ina3221.py

@@ -0,0 +1,79 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, CONF_NAME, \
+    CONF_POWER, CONF_SHUNT_RESISTANCE, CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_CHANNEL_1 = 'channel_1'
+CONF_CHANNEL_2 = 'channel_2'
+CONF_CHANNEL_3 = 'channel_3'
+
+INA3221Component = sensor.sensor_ns.class_('INA3221Component', PollingComponent, i2c.I2CDevice)
+INA3221VoltageSensor = sensor.sensor_ns.class_('INA3221VoltageSensor',
+                                               sensor.EmptyPollingParentSensor)
+INA3221CurrentSensor = sensor.sensor_ns.class_('INA3221CurrentSensor',
+                                               sensor.EmptyPollingParentSensor)
+INA3221PowerSensor = sensor.sensor_ns.class_('INA3221PowerSensor', sensor.EmptyPollingParentSensor)
+
+SENSOR_KEYS = [CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER]
+
+INA3221_CHANNEL_SCHEMA = vol.All(cv.Schema({
+    vol.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221VoltageSensor),
+    })),
+    vol.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221PowerSensor),
+    })),
+    vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1): vol.All(cv.resistance,
+                                                              vol.Range(min=0.0, max=32.0)),
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(INA3221Component),
+    vol.Optional(CONF_ADDRESS, default=0x40): cv.i2c_address,
+    vol.Optional(CONF_CHANNEL_1): INA3221_CHANNEL_SCHEMA,
+    vol.Optional(CONF_CHANNEL_2): INA3221_CHANNEL_SCHEMA,
+    vol.Optional(CONF_CHANNEL_3): INA3221_CHANNEL_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+})
+
+
+def to_code(config):
+    rhs = App.make_ina3221(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    ina = Pvariable(config[CONF_ID], rhs)
+    for i, channel in enumerate([CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3]):
+        if channel not in config:
+            continue
+        conf = config[channel]
+        if CONF_SHUNT_RESISTANCE in conf:
+            add(ina.set_shunt_resistance(i, conf[CONF_SHUNT_RESISTANCE]))
+        if CONF_BUS_VOLTAGE in conf:
+            c = conf[CONF_BUS_VOLTAGE]
+            sensor.register_sensor(ina.Pmake_bus_voltage_sensor(i, c[CONF_NAME]), c)
+        if CONF_SHUNT_VOLTAGE in conf:
+            c = conf[CONF_SHUNT_VOLTAGE]
+            sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(i, c[CONF_NAME]), c)
+        if CONF_CURRENT in conf:
+            c = conf[CONF_CURRENT]
+            sensor.register_sensor(ina.Pmake_current_sensor(i, c[CONF_NAME]), c)
+        if CONF_POWER in conf:
+            c = conf[CONF_POWER]
+            sensor.register_sensor(ina.Pmake_power_sensor(i, c[CONF_NAME]), c)
+
+    setup_component(ina, config)
+
+
+BUILD_FLAGS = '-DUSE_INA3221'

esphome/components/sensor/max31855.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App
+
+MAX31855Sensor = sensor.sensor_ns.class_('MAX31855Sensor', sensor.PollingSensorComponent,
+                                         spi.SPIDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MAX31855Sensor),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_max31855_sensor(config[CONF_NAME], spi_, cs,
+                                   config.get(CONF_UPDATE_INTERVAL))
+    max31855 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(max31855, config)
+    setup_component(max31855, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX31855_SENSOR'

esphome/components/sensor/max6675.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App
+
+MAX6675Sensor = sensor.sensor_ns.class_('MAX6675Sensor', sensor.PollingSensorComponent,
+                                        spi.SPIDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MAX6675Sensor),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_max6675_sensor(config[CONF_NAME], spi_, cs,
+                                  config.get(CONF_UPDATE_INTERVAL))
+    max6675 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(max6675, config)
+    setup_component(max6675, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX6675_SENSOR'

esphome/components/sensor/mhz19.py

@@ -0,0 +1,47 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CO2, CONF_ID, CONF_NAME, CONF_TEMPERATURE, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['uart']
+
+MHZ19Component = sensor.sensor_ns.class_('MHZ19Component', PollingComponent, uart.UARTDevice)
+MHZ19TemperatureSensor = sensor.sensor_ns.class_('MHZ19TemperatureSensor',
+                                                 sensor.EmptyPollingParentSensor)
+MHZ19CO2Sensor = sensor.sensor_ns.class_('MHZ19CO2Sensor', sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MHZ19Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+    vol.Required(CONF_CO2): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MHZ19CO2Sensor),
+    })),
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MHZ19TemperatureSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    rhs = App.make_mhz19_sensor(uart_, config[CONF_CO2][CONF_NAME],
+                                config.get(CONF_UPDATE_INTERVAL))
+    mhz19 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(mhz19.Pget_co2_sensor(), config[CONF_CO2])
+
+    if CONF_TEMPERATURE in config:
+        sensor.register_sensor(mhz19.Pmake_temperature_sensor(config[CONF_TEMPERATURE][CONF_NAME]),
+                               config[CONF_TEMPERATURE])
+
+    setup_component(mhz19, config)
+
+
+BUILD_FLAGS = '-DUSE_MHZ19'

esphome/components/sensor/mpu6050.py

@@ -0,0 +1,92 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+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'
+
+MPU6050Component = sensor.sensor_ns.class_('MPU6050Component', PollingComponent, i2c.I2CDevice)
+MPU6050AccelSensor = sensor.sensor_ns.class_('MPU6050AccelSensor', sensor.EmptyPollingParentSensor)
+MPU6050GyroSensor = sensor.sensor_ns.class_('MPU6050GyroSensor', sensor.EmptyPollingParentSensor)
+MPU6050TemperatureSensor = sensor.sensor_ns.class_('MPU6050TemperatureSensor',
+                                                   sensor.EmptyPollingParentSensor)
+
+SENSOR_KEYS = [CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z,
+               CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MPU6050Component),
+    vol.Optional(CONF_ADDRESS, default=0x68): cv.i2c_address,
+    vol.Optional(CONF_ACCEL_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
+    })),
+    vol.Optional(CONF_ACCEL_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
+    })),
+    vol.Optional(CONF_ACCEL_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
+    })),
+    vol.Optional(CONF_GYRO_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
+    })),
+    vol.Optional(CONF_GYRO_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
+    })),
+    vol.Optional(CONF_GYRO_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
+    })),
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050TemperatureSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_mpu6050_sensor(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    mpu = Pvariable(config[CONF_ID], rhs)
+    if CONF_ACCEL_X in config:
+        conf = config[CONF_ACCEL_X]
+        rhs = mpu.Pmake_accel_x_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_ACCEL_Y in config:
+        conf = config[CONF_ACCEL_Y]
+        rhs = mpu.Pmake_accel_y_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_ACCEL_Z in config:
+        conf = config[CONF_ACCEL_Z]
+        rhs = mpu.Pmake_accel_z_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_GYRO_X in config:
+        conf = config[CONF_GYRO_X]
+        rhs = mpu.Pmake_gyro_x_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_GYRO_Y in config:
+        conf = config[CONF_GYRO_Y]
+        rhs = mpu.Pmake_gyro_y_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_GYRO_Z in config:
+        conf = config[CONF_GYRO_Z]
+        rhs = mpu.Pmake_gyro_z_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        rhs = mpu.Pmake_temperature_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+
+    setup_component(mpu, config)
+
+
+BUILD_FLAGS = '-DUSE_MPU6050'

esphome/components/sensor/mqtt_subscribe.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['mqtt']
+
+MQTTSubscribeSensor = sensor.sensor_ns.class_('MQTTSubscribeSensor', sensor.Sensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MQTTSubscribeSensor),
+    vol.Required(CONF_TOPIC): cv.subscribe_topic,
+    vol.Optional(CONF_QOS): cv.mqtt_qos,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_mqtt_subscribe_sensor(config[CONF_NAME], config[CONF_TOPIC])
+    subs = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_QOS in config:
+        add(subs.set_qos(config[CONF_QOS]))
+
+    sensor.setup_sensor(subs, config)
+    setup_component(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_SENSOR'

esphome/components/sensor/ms5611.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+MS5611Component = sensor.sensor_ns.class_('MS5611Component', PollingComponent, i2c.I2CDevice)
+MS5611TemperatureSensor = sensor.sensor_ns.class_('MS5611TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+MS5611PressureSensor = sensor.sensor_ns.class_('MS5611PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MS5611Component),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MS5611TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MS5611PressureSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_ms5611_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    ms5611 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_ADDRESS in config:
+        add(ms5611.set_address(config[CONF_ADDRESS]))
+
+    sensor.setup_sensor(ms5611.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(ms5611.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(ms5611, config)
+
+
+BUILD_FLAGS = '-DUSE_MS5611'

esphome/components/sensor/pmsx003.py

@@ -0,0 +1,97 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_FORMALDEHYDE, CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_PM_10_0, \
+    CONF_PM_1_0, CONF_PM_2_5, CONF_TEMPERATURE, CONF_TYPE, CONF_UART_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['uart']
+
+PMSX003Component = sensor.sensor_ns.class_('PMSX003Component', uart.UARTDevice, Component)
+PMSX003Sensor = sensor.sensor_ns.class_('PMSX003Sensor', sensor.Sensor)
+
+CONF_PMSX003 = 'PMSX003'
+CONF_PMS5003T = 'PMS5003T'
+CONF_PMS5003ST = 'PMS5003ST'
+
+PMSX003Type = sensor.sensor_ns.enum('PMSX003Type')
+PMSX003_TYPES = {
+    CONF_PMSX003: PMSX003Type.PMSX003_TYPE_X003,
+    CONF_PMS5003T: PMSX003Type.PMSX003_TYPE_5003T,
+    CONF_PMS5003ST: PMSX003Type.PMSX003_TYPE_5003ST,
+}
+
+SENSORS_TO_TYPE = {
+    CONF_PM_1_0: [CONF_PMSX003],
+    CONF_PM_2_5: [CONF_PMSX003, CONF_PMS5003T, CONF_PMS5003ST],
+    CONF_PM_10_0: [CONF_PMSX003],
+    CONF_TEMPERATURE: [CONF_PMS5003T, CONF_PMS5003ST],
+    CONF_HUMIDITY: [CONF_PMS5003T, CONF_PMS5003ST],
+    CONF_FORMALDEHYDE: [CONF_PMS5003ST],
+}
+
+
+def validate_pmsx003_sensors(value):
+    for key, types in SENSORS_TO_TYPE.items():
+        if key in value and value[CONF_TYPE] not in types:
+            raise vol.Invalid(u"{} does not have {} sensor!".format(value[CONF_TYPE], key))
+    return value
+
+
+PMSX003_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PMSX003Sensor),
+})
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PMSX003Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+    vol.Required(CONF_TYPE): cv.one_of(*PMSX003_TYPES, upper=True),
+
+    vol.Optional(CONF_PM_1_0): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_PM_2_5): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_PM_10_0): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_HUMIDITY): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_FORMALDEHYDE): cv.nameable(PMSX003_SENSOR_SCHEMA),
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSORS_TO_TYPE))
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+
+    rhs = App.make_pmsx003(uart_, PMSX003_TYPES[config[CONF_TYPE]])
+    pms = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_PM_1_0 in config:
+        conf = config[CONF_PM_1_0]
+        sensor.register_sensor(pms.make_pm_1_0_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_PM_2_5 in config:
+        conf = config[CONF_PM_2_5]
+        sensor.register_sensor(pms.make_pm_2_5_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_PM_10_0 in config:
+        conf = config[CONF_PM_10_0]
+        sensor.register_sensor(pms.make_pm_10_0_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sensor.register_sensor(pms.make_temperature_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_HUMIDITY in config:
+        conf = config[CONF_HUMIDITY]
+        sensor.register_sensor(pms.make_humidity_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_FORMALDEHYDE in config:
+        conf = config[CONF_FORMALDEHYDE]
+        sensor.register_sensor(pms.make_formaldehyde_sensor(conf[CONF_NAME]), conf)
+
+    setup_component(pms, config)
+
+
+BUILD_FLAGS = '-DUSE_PMSX003'

esphome/components/sensor/pulse_counter.py

@@ -0,0 +1,78 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
+    CONF_NAME, CONF_PIN, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, CONF_NUMBER
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App
+
+PulseCounterCountMode = sensor.sensor_ns.enum('PulseCounterCountMode')
+COUNT_MODES = {
+    'DISABLE': PulseCounterCountMode.PULSE_COUNTER_DISABLE,
+    'INCREMENT': PulseCounterCountMode.PULSE_COUNTER_INCREMENT,
+    'DECREMENT': PulseCounterCountMode.PULSE_COUNTER_DECREMENT,
+}
+
+COUNT_MODE_SCHEMA = cv.one_of(*COUNT_MODES, upper=True)
+
+PulseCounterBase = sensor.sensor_ns.class_('PulseCounterBase')
+PulseCounterSensorComponent = sensor.sensor_ns.class_('PulseCounterSensorComponent',
+                                                      sensor.PollingSensorComponent,
+                                                      PulseCounterBase)
+
+
+def validate_internal_filter(value):
+    if CORE.is_esp32:
+        if isinstance(value, int):
+            raise vol.Invalid("Please specify the internal filter in microseconds now "
+                              "(since 1.7.0). For example '17ms'")
+        value = cv.positive_time_period_microseconds(value)
+        if value.total_microseconds > 13:
+            raise vol.Invalid("Maximum internal filter value for ESP32 is 13us")
+        return value
+
+    return cv.positive_time_period_microseconds(value)
+
+
+def validate_pulse_counter_pin(value):
+    value = pins.internal_gpio_input_pin_schema(value)
+    if CORE.is_esp8266 and value[CONF_NUMBER] >= 16:
+        raise vol.Invalid("Pins GPIO16 and GPIO17 cannot be used as pulse counters on ESP8266.")
+    return value
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PulseCounterSensorComponent),
+    vol.Required(CONF_PIN): validate_pulse_counter_pin,
+    vol.Optional(CONF_COUNT_MODE): cv.Schema({
+        vol.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
+        vol.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
+    }),
+    vol.Optional(CONF_INTERNAL_FILTER): validate_internal_filter,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_pulse_counter_sensor(config[CONF_NAME], pin,
+                                        config.get(CONF_UPDATE_INTERVAL))
+    pcnt = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_COUNT_MODE in config:
+        rising_edge = COUNT_MODES[config[CONF_COUNT_MODE][CONF_RISING_EDGE]]
+        falling_edge = COUNT_MODES[config[CONF_COUNT_MODE][CONF_FALLING_EDGE]]
+        add(pcnt.set_edge_mode(rising_edge, falling_edge))
+    if CONF_INTERNAL_FILTER in config:
+        add(pcnt.set_filter_us(config[CONF_INTERNAL_FILTER]))
+
+    sensor.setup_sensor(pcnt, config)
+    setup_component(pcnt, config)
+
+
+BUILD_FLAGS = '-DUSE_PULSE_COUNTER_SENSOR'

esphome/components/sensor/rotary_encoder.py

@@ -0,0 +1,72 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_RESOLUTION, CONF_MIN_VALUE, CONF_MAX_VALUE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+RotaryEncoderResolution = sensor.sensor_ns.enum('RotaryEncoderResolution')
+RESOLUTIONS = {
+    1: RotaryEncoderResolution.ROTARY_ENCODER_1_PULSE_PER_CYCLE,
+    2: RotaryEncoderResolution.ROTARY_ENCODER_2_PULSES_PER_CYCLE,
+    4: RotaryEncoderResolution.ROTARY_ENCODER_4_PULSES_PER_CYCLE,
+}
+
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_RESET = 'pin_reset'
+
+RotaryEncoderSensor = sensor.sensor_ns.class_('RotaryEncoderSensor', sensor.Sensor, Component)
+
+
+def validate_min_max_value(config):
+    if CONF_MIN_VALUE in config and CONF_MAX_VALUE in config:
+        min_val = config[CONF_MIN_VALUE]
+        max_val = config[CONF_MAX_VALUE]
+        if min_val >= max_val:
+            raise vol.Invalid("Max value {} must be smaller than min value {}"
+                              "".format(max_val, min_val))
+    return config
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RotaryEncoderSensor),
+    vol.Required(CONF_PIN_A): vol.All(pins.internal_gpio_input_pin_schema,
+                                      pins.validate_has_interrupt),
+    vol.Required(CONF_PIN_B): vol.All(pins.internal_gpio_input_pin_schema,
+                                      pins.validate_has_interrupt),
+    vol.Optional(CONF_PIN_RESET): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_RESOLUTION): cv.one_of(*RESOLUTIONS, int=True),
+    vol.Optional(CONF_MIN_VALUE): cv.int_,
+    vol.Optional(CONF_MAX_VALUE): cv.int_,
+}).extend(cv.COMPONENT_SCHEMA.schema), validate_min_max_value)
+
+
+def to_code(config):
+    for pin_a in gpio_input_pin_expression(config[CONF_PIN_A]):
+        yield
+    for pin_b in gpio_input_pin_expression(config[CONF_PIN_B]):
+        yield
+    rhs = App.make_rotary_encoder_sensor(config[CONF_NAME], pin_a, pin_b)
+    encoder = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_PIN_RESET in config:
+        for pin_i in gpio_input_pin_expression(config[CONF_PIN_RESET]):
+            yield
+        add(encoder.set_reset_pin(pin_i))
+    if CONF_RESOLUTION in config:
+        resolution = RESOLUTIONS[config[CONF_RESOLUTION]]
+        add(encoder.set_resolution(resolution))
+    if CONF_MIN_VALUE in config:
+        add(encoder.set_min_value(config[CONF_MIN_VALUE]))
+    if CONF_MAX_VALUE in config:
+        add(encoder.set_max_value(config[CONF_MAX_VALUE]))
+
+    sensor.setup_sensor(encoder, config)
+    setup_component(encoder, config)
+
+
+BUILD_FLAGS = '-DUSE_ROTARY_ENCODER_SENSOR'

esphome/components/sensor/sds011.py

@@ -0,0 +1,70 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import (CONF_ID, CONF_NAME, CONF_PM_10_0, CONF_PM_2_5, CONF_RX_ONLY,
+                           CONF_UART_ID, CONF_UPDATE_INTERVAL)
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['uart']
+
+SDS011Component = sensor.sensor_ns.class_('SDS011Component', uart.UARTDevice, Component)
+SDS011Sensor = sensor.sensor_ns.class_('SDS011Sensor', sensor.EmptySensor)
+
+
+def validate_sds011_rx_mode(value):
+    if CONF_UPDATE_INTERVAL in value and not value.get(CONF_RX_ONLY):
+        update_interval = value[CONF_UPDATE_INTERVAL]
+        if update_interval.total_minutes > 30:
+            raise vol.Invalid("Maximum update interval is 30min")
+    elif value.get(CONF_RX_ONLY) and CONF_UPDATE_INTERVAL in value:
+        # update_interval does not affect anything in rx-only mode, let's warn user about
+        # that
+        raise vol.Invalid("update_interval has no effect in rx_only mode. Please remove it.",
+                          path=['update_interval'])
+    return value
+
+
+SDS011_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SDS011Sensor),
+})
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SDS011Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+
+    vol.Optional(CONF_RX_ONLY): cv.boolean,
+
+    vol.Optional(CONF_PM_2_5): cv.nameable(SDS011_SENSOR_SCHEMA),
+    vol.Optional(CONF_PM_10_0): cv.nameable(SDS011_SENSOR_SCHEMA),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_minutes,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_PM_2_5, CONF_PM_10_0),
+                          validate_sds011_rx_mode)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+
+    rhs = App.make_sds011(uart_)
+    sds011 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_UPDATE_INTERVAL in config:
+        add(sds011.set_update_interval_min(config.get(CONF_UPDATE_INTERVAL)))
+    if CONF_RX_ONLY in config:
+        add(sds011.set_rx_mode_only(config[CONF_RX_ONLY]))
+
+    if CONF_PM_2_5 in config:
+        conf = config[CONF_PM_2_5]
+        sensor.register_sensor(sds011.make_pm_2_5_sensor(conf[CONF_NAME]), conf)
+    if CONF_PM_10_0 in config:
+        conf = config[CONF_PM_10_0]
+        sensor.register_sensor(sds011.make_pm_10_0_sensor(conf[CONF_NAME]), conf)
+
+    setup_component(sds011, config)
+
+
+BUILD_FLAGS = '-DUSE_SDS011'

esphome/components/sensor/sht3xd.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_ID, CONF_NAME, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+SHT3XDComponent = sensor.sensor_ns.class_('SHT3XDComponent', PollingComponent, i2c.I2CDevice)
+SHT3XDTemperatureSensor = sensor.sensor_ns.class_('SHT3XDTemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+SHT3XDHumiditySensor = sensor.sensor_ns.class_('SHT3XDHumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SHT3XDComponent),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(SHT3XDTemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(SHT3XDHumiditySensor),
+    })),
+    vol.Optional(CONF_ADDRESS, default=0x44): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_sht3xd_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    sht3xd = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(sht3xd.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(sht3xd.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(sht3xd, config)
+
+
+BUILD_FLAGS = '-DUSE_SHT3XD'

esphome/components/sensor/tcs34725.py

@@ -0,0 +1,104 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_COLOR_TEMPERATURE, CONF_GAIN, CONF_ID, \
+    CONF_ILLUMINANCE, CONF_INTEGRATION_TIME, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_RED_CHANNEL = 'red_channel'
+CONF_GREEN_CHANNEL = 'green_channel'
+CONF_BLUE_CHANNEL = 'blue_channel'
+CONF_CLEAR_CHANNEL = 'clear_channel'
+
+TCS34725Component = sensor.sensor_ns.class_('TCS34725Component', PollingComponent,
+                                            i2c.I2CDevice)
+
+TCS34725IntegrationTime = sensor.sensor_ns.enum('TCS34725IntegrationTime')
+TCS34725_INTEGRATION_TIMES = {
+    '2.4ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_2_4MS,
+    '24ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_24MS,
+    '50ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_50MS,
+    '101ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_101MS,
+    '154ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_154MS,
+    '700ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_700MS,
+}
+
+TCS34725Gain = sensor.sensor_ns.enum('TCS34725Gain')
+TCS34725_GAINS = {
+    '1X': TCS34725Gain.TCS34725_GAIN_1X,
+    '4X': TCS34725Gain.TCS34725_GAIN_4X,
+    '16X': TCS34725Gain.TCS34725_GAIN_16X,
+    '60X': TCS34725Gain.TCS34725_GAIN_60X,
+}
+
+TCS35725IlluminanceSensor = sensor.sensor_ns.class_('TCS35725IlluminanceSensor',
+                                                    sensor.EmptyPollingParentSensor)
+TCS35725ColorTemperatureSensor = sensor.sensor_ns.class_('TCS35725ColorTemperatureSensor',
+                                                         sensor.EmptyPollingParentSensor)
+TCS35725ColorChannelSensor = sensor.sensor_ns.class_('TCS35725ColorChannelSensor',
+                                                     sensor.EmptyPollingParentSensor)
+
+COLOR_CHANNEL_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TCS35725ColorChannelSensor),
+})
+
+SENSOR_KEYS = [CONF_RED_CHANNEL, CONF_GREEN_CHANNEL, CONF_BLUE_CHANNEL,
+               CONF_CLEAR_CHANNEL, CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TCS34725Component),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_RED_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_GREEN_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_BLUE_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_CLEAR_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_ILLUMINANCE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(TCS35725IlluminanceSensor),
+    })),
+    vol.Optional(CONF_COLOR_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(TCS35725ColorTemperatureSensor),
+    })),
+    vol.Optional(CONF_INTEGRATION_TIME): cv.one_of(*TCS34725_INTEGRATION_TIMES, lower=True),
+    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS), upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_tcs34725(config.get(CONF_UPDATE_INTERVAL))
+    tcs = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(tcs.set_address(config[CONF_ADDRESS]))
+    if CONF_INTEGRATION_TIME in config:
+        add(tcs.set_integration_time(TCS34725_INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
+    if CONF_GAIN in config:
+        add(tcs.set_gain(TCS34725_GAINS[config[CONF_GAIN]]))
+    if CONF_RED_CHANNEL in config:
+        conf = config[CONF_RED_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_red_sensor(conf[CONF_NAME]), conf)
+    if CONF_GREEN_CHANNEL in config:
+        conf = config[CONF_GREEN_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_green_sensor(conf[CONF_NAME]), conf)
+    if CONF_BLUE_CHANNEL in config:
+        conf = config[CONF_BLUE_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_blue_sensor(conf[CONF_NAME]), conf)
+    if CONF_CLEAR_CHANNEL in config:
+        conf = config[CONF_CLEAR_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_clear_sensor(conf[CONF_NAME]), conf)
+    if CONF_ILLUMINANCE in config:
+        conf = config[CONF_ILLUMINANCE]
+        sensor.register_sensor(tcs.Pmake_illuminance_sensor(conf[CONF_NAME]), conf)
+    if CONF_COLOR_TEMPERATURE in config:
+        conf = config[CONF_COLOR_TEMPERATURE]
+        sensor.register_sensor(tcs.Pmake_color_temperature_sensor(conf[CONF_NAME]), conf)
+
+    setup_component(tcs, config)
+
+
+BUILD_FLAGS = '-DUSE_TCS34725'

esphome/components/sensor/template.py

@@ -0,0 +1,54 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, float_, optional
+
+TemplateSensor = sensor.sensor_ns.class_('TemplateSensor', sensor.PollingSensorComponent)
+SensorPublishAction = sensor.sensor_ns.class_('SensorPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSensor),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    template = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(template, config)
+    setup_component(template, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(float_)):
+            yield
+        add(template.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SENSOR'
+
+CONF_SENSOR_TEMPLATE_PUBLISH = 'sensor.template.publish'
+SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(sensor.Sensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.float_),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SENSOR_TEMPLATE_PUBLISH, SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def sensor_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_sensor_publish_action(template_arg)
+    type = SensorPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, float_):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/sensor/total_daily_energy.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome.components import sensor, time
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_TIME_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['time']
+
+CONF_POWER_ID = 'power_id'
+TotalDailyEnergy = sensor.sensor_ns.class_('TotalDailyEnergy', sensor.Sensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TotalDailyEnergy),
+    cv.GenerateID(CONF_TIME_ID): cv.use_variable_id(time.RealTimeClockComponent),
+    vol.Required(CONF_POWER_ID): cv.use_variable_id(sensor.Sensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for time_ in get_variable(config[CONF_TIME_ID]):
+        yield
+    for sens in get_variable(config[CONF_POWER_ID]):
+        yield
+    rhs = App.make_total_daily_energy_sensor(config[CONF_NAME], time_, sens)
+    total_energy = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(total_energy, config)
+    setup_component(total_energy, config)
+
+
+BUILD_FLAGS = '-DUSE_TOTAL_DAILY_ENERGY_SENSOR'

esphome/components/sensor/tsl2561.py

@@ -0,0 +1,65 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_GAIN, CONF_ID, CONF_INTEGRATION_TIME, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['i2c']
+
+TSL2561IntegrationTime = sensor.sensor_ns.enum('TSL2561IntegrationTime')
+INTEGRATION_TIMES = {
+    14: TSL2561IntegrationTime.TSL2561_INTEGRATION_14MS,
+    101: TSL2561IntegrationTime.TSL2561_INTEGRATION_101MS,
+    402: TSL2561IntegrationTime.TSL2561_INTEGRATION_402MS,
+}
+
+TSL2561Gain = sensor.sensor_ns.enum('TSL2561Gain')
+GAINS = {
+    '1X': TSL2561Gain.TSL2561_GAIN_1X,
+    '16X': TSL2561Gain.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
+
+
+TSL2561Sensor = sensor.sensor_ns.class_('TSL2561Sensor', sensor.PollingSensorComponent,
+                                        i2c.I2CDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TSL2561Sensor),
+    vol.Optional(CONF_ADDRESS, default=0x39): cv.i2c_address,
+    vol.Optional(CONF_INTEGRATION_TIME): validate_integration_time,
+    vol.Optional(CONF_GAIN): cv.one_of(*GAINS, upper=True),
+    vol.Optional(CONF_IS_CS_PACKAGE): cv.boolean,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_tsl2561_sensor(config[CONF_NAME], config[CONF_ADDRESS],
+                                  config.get(CONF_UPDATE_INTERVAL))
+    tsl2561 = Pvariable(config[CONF_ID], rhs)
+
+    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, config)
+    setup_component(tsl2561, config)
+
+
+BUILD_FLAGS = '-DUSE_TSL2561'

esphome/components/sensor/ultrasonic.py

@@ -0,0 +1,54 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ECHO_PIN, CONF_ID, CONF_NAME, CONF_TRIGGER_PIN, \
+    CONF_UPDATE_INTERVAL, CONF_TIMEOUT
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App
+
+CONF_PULSE_TIME = 'pulse_time'
+
+UltrasonicSensorComponent = sensor.sensor_ns.class_('UltrasonicSensorComponent',
+                                                    sensor.PollingSensorComponent)
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UltrasonicSensorComponent),
+    vol.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema,
+
+    vol.Optional(CONF_TIMEOUT): cv.distance,
+    vol.Optional(CONF_PULSE_TIME): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+
+    vol.Optional('timeout_meter'): cv.invalid("The timeout_meter option has been renamed "
+                                              "to 'timeout'."),
+    vol.Optional('timeout_time'): cv.invalid("The timeout_time option has been removed. Please "
+                                             "use 'timeout'."),
+}))
+
+
+def to_code(config):
+    for trigger in gpio_output_pin_expression(config[CONF_TRIGGER_PIN]):
+        yield
+    for echo in gpio_input_pin_expression(config[CONF_ECHO_PIN]):
+        yield
+    rhs = App.make_ultrasonic_sensor(config[CONF_NAME], trigger, echo,
+                                     config.get(CONF_UPDATE_INTERVAL))
+    ultrasonic = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_TIMEOUT in config:
+        add(ultrasonic.set_timeout_us(config[CONF_TIMEOUT] / (0.000343 / 2)))
+
+    if CONF_PULSE_TIME in config:
+        add(ultrasonic.set_pulse_time_us(config[CONF_PULSE_TIME]))
+
+    sensor.setup_sensor(ultrasonic, config)
+    setup_component(ultrasonic, config)
+
+
+BUILD_FLAGS = '-DUSE_ULTRASONIC_SENSOR'

esphome/components/sensor/uptime.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+UptimeSensor = sensor.sensor_ns.class_('UptimeSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UptimeSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_uptime_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    uptime = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(uptime, config)
+    setup_component(uptime, config)
+
+
+BUILD_FLAGS = '-DUSE_UPTIME_SENSOR'

esphome/components/sensor/wifi_signal.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+WiFiSignalSensor = sensor.sensor_ns.class_('WiFiSignalSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(WiFiSignalSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_wifi_signal_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    wifi = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(wifi, config)
+    setup_component(wifi, config)
+
+
+BUILD_FLAGS = '-DUSE_WIFI_SIGNAL_SENSOR'

esphome/components/sensor/xiaomi_miflora.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+from esphome.components import esp32_ble_tracker, sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_BATTERY_LEVEL, CONF_CONDUCTIVITY, CONF_ID, CONF_ILLUMINANCE, \
+    CONF_MAC_ADDRESS, CONF_MOISTURE, CONF_NAME, CONF_TEMPERATURE
+from esphome.cpp_generator import Pvariable, get_variable
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(esp32_ble_tracker.XiaomiDevice),
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_MOISTURE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_ILLUMINANCE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_CONDUCTIVITY): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_BATTERY_LEVEL): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+})
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_xiaomi_device(make_address_array(config[CONF_MAC_ADDRESS]))
+    dev = Pvariable(config[CONF_ID], rhs)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sensor.register_sensor(dev.Pmake_temperature_sensor(conf[CONF_NAME]), conf)
+    if CONF_MOISTURE in config:
+        conf = config[CONF_MOISTURE]
+        sensor.register_sensor(dev.Pmake_moisture_sensor(conf[CONF_NAME]), conf)
+    if CONF_ILLUMINANCE in config:
+        conf = config[CONF_ILLUMINANCE]
+        sensor.register_sensor(dev.Pmake_illuminance_sensor(conf[CONF_NAME]), conf)
+    if CONF_CONDUCTIVITY in config:
+        conf = config[CONF_CONDUCTIVITY]
+        sensor.register_sensor(dev.Pmake_conductivity_sensor(conf[CONF_NAME]), conf)
+    if CONF_BATTERY_LEVEL in config:
+        conf = config[CONF_BATTERY_LEVEL]
+        sensor.register_sensor(dev.Pmake_battery_level_sensor(conf[CONF_NAME]), conf)

esphome/components/sensor/xiaomi_mijia.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome.components import esp32_ble_tracker, sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_MAKE_ID, \
+    CONF_NAME, CONF_TEMPERATURE
+from esphome.cpp_generator import Pvariable, get_variable
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(esp32_ble_tracker.XiaomiDevice),
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_HUMIDITY): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_BATTERY_LEVEL): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+})
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_xiaomi_device(make_address_array(config[CONF_MAC_ADDRESS]))
+    dev = Pvariable(config[CONF_MAKE_ID], rhs)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sensor.register_sensor(dev.Pmake_temperature_sensor(conf[CONF_NAME]), conf)
+    if CONF_HUMIDITY in config:
+        conf = config[CONF_HUMIDITY]
+        sensor.register_sensor(dev.Pmake_humidity_sensor(conf[CONF_NAME]), conf)
+    if CONF_BATTERY_LEVEL in config:
+        conf = config[CONF_BATTERY_LEVEL]
+        sensor.register_sensor(dev.Pmake_battery_level_sensor(conf[CONF_NAME]), conf)

esphome/components/servo.py

@@ -0,0 +1,59 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components.output import FloatOutput
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_IDLE_LEVEL, CONF_MAX_LEVEL, CONF_MIN_LEVEL, CONF_OUTPUT, \
+    CONF_LEVEL
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns, Action, float_
+
+Servo = esphome_ns.class_('Servo', Component)
+ServoWriteAction = esphome_ns.class_('ServoWriteAction', Action)
+
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(Servo),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(FloatOutput),
+    vol.Optional(CONF_MIN_LEVEL, default='3%'): cv.percentage,
+    vol.Optional(CONF_IDLE_LEVEL, default='7.5%'): cv.percentage,
+    vol.Optional(CONF_MAX_LEVEL, default='12%'): cv.percentage,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for out in get_variable(config[CONF_OUTPUT]):
+        yield
+
+    rhs = App.register_component(Servo.new(out))
+    servo = Pvariable(config[CONF_ID], rhs)
+
+    add(servo.set_min_level(config[CONF_MIN_LEVEL]))
+    add(servo.set_idle_level(config[CONF_IDLE_LEVEL]))
+    add(servo.set_max_level(config[CONF_MAX_LEVEL]))
+
+    setup_component(servo, config)
+
+
+BUILD_FLAGS = '-DUSE_SERVO'
+
+CONF_SERVO_WRITE = 'servo.write'
+SERVO_WRITE_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(Servo),
+    vol.Required(CONF_LEVEL): cv.templatable(cv.possibly_negative_percentage),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SERVO_WRITE, SERVO_WRITE_ACTION_SCHEMA)
+def servo_write_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = ServoWriteAction.new(template_arg, var)
+    type = ServoWriteAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_LEVEL], args, float_):
+        yield None
+    add(action.set_value(template_))
+    yield action

esphome/components/spi.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_CLK_PIN, CONF_ID, CONF_MISO_PIN, CONF_MOSI_PIN
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+SPIComponent = esphome_ns.class_('SPIComponent', Component)
+SPIDevice = esphome_ns.class_('SPIDevice')
+MULTI_CONF = True
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(SPIComponent),
+    vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_MISO_PIN): pins.gpio_input_pin_schema,
+    vol.Optional(CONF_MOSI_PIN): pins.gpio_output_pin_schema,
+}), cv.has_at_least_one_key(CONF_MISO_PIN, CONF_MOSI_PIN))
+
+
+def to_code(config):
+    for clk in gpio_output_pin_expression(config[CONF_CLK_PIN]):
+        yield
+    rhs = App.init_spi(clk)
+    spi = Pvariable(config[CONF_ID], rhs)
+    if CONF_MISO_PIN in config:
+        for miso in gpio_input_pin_expression(config[CONF_MISO_PIN]):
+            yield
+        add(spi.set_miso(miso))
+    if CONF_MOSI_PIN in config:
+        for mosi in gpio_input_pin_expression(config[CONF_MOSI_PIN]):
+            yield
+        add(spi.set_mosi(mosi))
+
+    setup_component(spi, config)
+
+
+BUILD_FLAGS = '-DUSE_SPI'

esphome/components/status_led.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv, pins
+from esphome.const import CONF_ID, CONF_PIN
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+StatusLEDComponent = esphome_ns.class_('StatusLEDComponent', Component)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(StatusLEDComponent),
+    vol.Optional(CONF_PIN): pins.gpio_output_pin_schema,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_status_led(pin)
+    var = Pvariable(config[CONF_ID], rhs)
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_STATUS_LED'

esphome/components/stepper/__init__.py

@@ -0,0 +1,124 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+import esphome.config_validation as cv
+from esphome.const import CONF_ACCELERATION, CONF_DECELERATION, CONF_ID, CONF_MAX_SPEED, \
+    CONF_POSITION, CONF_TARGET
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_types import Action, esphome_ns, int32
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+# pylint: disable=invalid-name
+stepper_ns = esphome_ns.namespace('stepper')
+Stepper = stepper_ns.class_('Stepper')
+
+SetTargetAction = stepper_ns.class_('SetTargetAction', Action)
+ReportPositionAction = stepper_ns.class_('ReportPositionAction', Action)
+
+
+def validate_acceleration(value):
+    value = cv.string(value)
+    for suffix in ('steps/s^2', 'steps/s*s', 'steps/s/s', 'steps/ss', 'steps/(s*s)'):
+        if value.endswith(suffix):
+            value = value[:-len(suffix)]
+
+    if value == 'inf':
+        return 1e6
+
+    try:
+        value = float(value)
+    except ValueError:
+        raise vol.Invalid("Expected acceleration as floating point number, got {}".format(value))
+
+    if value <= 0:
+        raise vol.Invalid("Acceleration must be larger than 0 steps/s^2!")
+
+    return value
+
+
+def validate_speed(value):
+    value = cv.string(value)
+    for suffix in ('steps/s', 'steps/s'):
+        if value.endswith(suffix):
+            value = value[:-len(suffix)]
+
+    if value == 'inf':
+        return 1e6
+
+    try:
+        value = float(value)
+    except ValueError:
+        raise vol.Invalid("Expected speed as floating point number, got {}".format(value))
+
+    if value <= 0:
+        raise vol.Invalid("Speed must be larger than 0 steps/s!")
+
+    return value
+
+
+STEPPER_SCHEMA = cv.Schema({
+    vol.Required(CONF_MAX_SPEED): validate_speed,
+    vol.Optional(CONF_ACCELERATION): validate_acceleration,
+    vol.Optional(CONF_DECELERATION): validate_acceleration,
+})
+
+STEPPER_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(STEPPER_SCHEMA.schema)
+
+
+def setup_stepper_core_(stepper_var, config):
+    if CONF_ACCELERATION in config:
+        add(stepper_var.set_acceleration(config[CONF_ACCELERATION]))
+    if CONF_DECELERATION in config:
+        add(stepper_var.set_deceleration(config[CONF_DECELERATION]))
+    if CONF_MAX_SPEED in config:
+        add(stepper_var.set_max_speed(config[CONF_MAX_SPEED]))
+
+
+def setup_stepper(stepper_var, config):
+    CORE.add_job(setup_stepper_core_, stepper_var, config)
+
+
+BUILD_FLAGS = '-DUSE_STEPPER'
+
+CONF_STEPPER_SET_TARGET = 'stepper.set_target'
+STEPPER_SET_TARGET_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(Stepper),
+    vol.Required(CONF_TARGET): cv.templatable(cv.int_),
+})
+
+
+@ACTION_REGISTRY.register(CONF_STEPPER_SET_TARGET, STEPPER_SET_TARGET_ACTION_SCHEMA)
+def stepper_set_target_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_set_target_action(template_arg)
+    type = SetTargetAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_TARGET], args, int32):
+        yield None
+    add(action.set_target(template_))
+    yield action
+
+
+CONF_STEPPER_REPORT_POSITION = 'stepper.report_position'
+STEPPER_REPORT_POSITION_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(Stepper),
+    vol.Required(CONF_POSITION): cv.templatable(cv.int_),
+})
+
+
+@ACTION_REGISTRY.register(CONF_STEPPER_REPORT_POSITION, STEPPER_REPORT_POSITION_ACTION_SCHEMA)
+def stepper_report_position_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_report_position_action(template_arg)
+    type = ReportPositionAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_POSITION], args, int32):
+        yield None
+    add(action.set_position(template_))
+    yield action

esphome/components/stepper/a4988.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import stepper
+import esphome.config_validation as cv
+from esphome.const import CONF_DIR_PIN, CONF_ID, CONF_SLEEP_PIN, CONF_STEP_PIN
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+A4988 = stepper.stepper_ns.class_('A4988', stepper.Stepper, Component)
+
+PLATFORM_SCHEMA = stepper.STEPPER_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(A4988),
+    vol.Required(CONF_STEP_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_DIR_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_SLEEP_PIN): pins.gpio_output_pin_schema,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for step_pin in gpio_output_pin_expression(config[CONF_STEP_PIN]):
+        yield
+    for dir_pin in gpio_output_pin_expression(config[CONF_DIR_PIN]):
+        yield
+    rhs = App.make_a4988(step_pin, dir_pin)
+    a4988 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_SLEEP_PIN in config:
+        for sleep_pin in gpio_output_pin_expression(config[CONF_SLEEP_PIN]):
+            yield
+        add(a4988.set_sleep_pin(sleep_pin))
+
+    stepper.setup_stepper(a4988, config)
+    setup_component(a4988, config)
+
+
+BUILD_FLAGS = '-DUSE_A4988'

esphome/components/stepper/uln2003.py

@@ -0,0 +1,55 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import stepper
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_PIN_A, CONF_PIN_B, CONF_PIN_C, CONF_PIN_D, \
+    CONF_SLEEP_WHEN_DONE, CONF_STEP_MODE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+ULN2003StepMode = stepper.stepper_ns.enum('ULN2003StepMode')
+
+STEP_MODES = {
+    'FULL_STEP': ULN2003StepMode.ULN2003_STEP_MODE_FULL_STEP,
+    'HALF_STEP': ULN2003StepMode.ULN2003_STEP_MODE_HALF_STEP,
+    'WAVE_DRIVE': ULN2003StepMode.ULN2003_STEP_MODE_WAVE_DRIVE,
+}
+
+ULN2003 = stepper.stepper_ns.class_('ULN2003', stepper.Stepper, Component)
+
+PLATFORM_SCHEMA = stepper.STEPPER_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(ULN2003),
+    vol.Required(CONF_PIN_A): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_B): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_C): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_D): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_SLEEP_WHEN_DONE): cv.boolean,
+    vol.Optional(CONF_STEP_MODE): cv.one_of(*STEP_MODES, upper=True, space='_')
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin_a in gpio_output_pin_expression(config[CONF_PIN_A]):
+        yield
+    for pin_b in gpio_output_pin_expression(config[CONF_PIN_B]):
+        yield
+    for pin_c in gpio_output_pin_expression(config[CONF_PIN_C]):
+        yield
+    for pin_d in gpio_output_pin_expression(config[CONF_PIN_D]):
+        yield
+    rhs = App.make_uln2003(pin_a, pin_b, pin_c, pin_d)
+    uln = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_SLEEP_WHEN_DONE in config:
+        add(uln.set_sleep_when_done(config[CONF_SLEEP_WHEN_DONE]))
+
+    if CONF_STEP_MODE in config:
+        add(uln.set_step_mode(STEP_MODES[config[CONF_STEP_MODE]]))
+
+    stepper.setup_stepper(uln, config)
+    setup_component(uln, config)
+
+
+BUILD_FLAGS = '-DUSE_ULN2003'

esphome/components/substitutions.py

@@ -0,0 +1,136 @@
+import logging
+import re
+
+import voluptuous as vol
+
+from esphome import core
+import esphome.config_validation as cv
+from esphome.core import EsphomeError
+from esphome.py_compat import string_types
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_SUBSTITUTIONS = 'substitutions'
+
+VALID_SUBSTITUTIONS_CHARACTERS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' \
+                                 '0123456789_'
+
+
+def validate_substitution_key(value):
+    value = cv.string(value)
+    if not value:
+        raise vol.Invalid("Substitution key must not be empty")
+    if value[0] == '$':
+        value = value[1:]
+    if value[0].isdigit():
+        raise vol.Invalid("First character in substitutions cannot be a digit.")
+    for char in value:
+        if char not in VALID_SUBSTITUTIONS_CHARACTERS:
+            raise vol.Invalid(
+                u"Substitution must only consist of upper/lowercase characters, the underscore "
+                u"and numbers. The character '{}' cannot be used".format(char))
+    return value
+
+
+CONFIG_SCHEMA = cv.Schema({
+    validate_substitution_key: cv.string_strict,
+})
+
+
+def to_code(config):
+    pass
+
+
+VARIABLE_PROG = re.compile('\\$([{0}]+|\\{{[{0}]*\\}})'.format(VALID_SUBSTITUTIONS_CHARACTERS))
+
+
+def _expand_substitutions(substitutions, value, path):
+    if u'$' not in value:
+        return value
+
+    orig_value = value
+
+    i = 0
+    while True:
+        m = VARIABLE_PROG.search(value, i)
+        if not m:
+            # Nothing more to match. Done
+            break
+
+        i, j = m.span(0)
+        name = m.group(1)
+        if name.startswith(u'{') and name.endswith(u'}'):
+            name = name[1:-1]
+        if name not in substitutions:
+            _LOGGER.warning(u"Found '%s' (see %s) which looks like a substitution, but '%s' was "
+                            u"not declared", orig_value, u'->'.join(str(x) for x in path), name)
+            i = j
+            continue
+
+        sub = substitutions[name]
+        tail = value[j:]
+        value = value[:i] + sub
+        i = len(value)
+        value += tail
+    return value
+
+
+def _substitute_item(substitutions, item, path):
+    if isinstance(item, list):
+        for i, it in enumerate(item):
+            sub = _substitute_item(substitutions, it, path + [i])
+            if sub is not None:
+                item[i] = sub
+    elif isinstance(item, dict):
+        replace_keys = []
+        for k, v in item.items():
+            if path or k != CONF_SUBSTITUTIONS:
+                sub = _substitute_item(substitutions, k, path + [k])
+                if sub is not None:
+                    replace_keys.append((k, sub))
+            sub = _substitute_item(substitutions, v, path + [k])
+            if sub is not None:
+                item[k] = sub
+        for old, new in replace_keys:
+            item[new] = item[old]
+            del item[old]
+    elif isinstance(item, string_types):
+        sub = _expand_substitutions(substitutions, item, path)
+        if sub != item:
+            return sub
+    elif isinstance(item, core.Lambda):
+        sub = _expand_substitutions(substitutions, item.value, path)
+        if sub != item:
+            item.value = sub
+    return None
+
+
+def do_substitution_pass(config):
+    if CONF_SUBSTITUTIONS not in config:
+        return config
+
+    substitutions = config[CONF_SUBSTITUTIONS]
+    if not isinstance(substitutions, dict):
+        raise EsphomeError(u"Substitutions must be a key to value mapping, got {}"
+                           u"".format(type(substitutions)))
+
+    key = ''
+    try:
+        replace_keys = []
+        for key, value in substitutions.items():
+            sub = validate_substitution_key(key)
+            if sub != key:
+                replace_keys.append((key, sub))
+            substitutions[key] = cv.string_strict(value)
+        for old, new in replace_keys:
+            substitutions[new] = substitutions[old]
+            del substitutions[old]
+    except vol.Invalid as err:
+        err.path.append(key)
+
+        raise EsphomeError(u"Error while parsing substitutions: {}".format(err))
+
+    config[CONF_SUBSTITUTIONS] = substitutions
+    _substitute_item(substitutions, config, [])
+
+    return config

esphome/components/switch/__init__.py

@@ -0,0 +1,151 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_INVERTED, CONF_MQTT_ID, \
+    CONF_ON_TURN_OFF, CONF_ON_TURN_ON, CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_types import Action, App, Nameable, Trigger, esphome_ns
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+switch_ns = esphome_ns.namespace('switch_')
+Switch = switch_ns.class_('Switch', Nameable)
+SwitchPtr = Switch.operator('ptr')
+MQTTSwitchComponent = switch_ns.class_('MQTTSwitchComponent', mqtt.MQTTComponent)
+
+ToggleAction = switch_ns.class_('ToggleAction', Action)
+TurnOffAction = switch_ns.class_('TurnOffAction', Action)
+TurnOnAction = switch_ns.class_('TurnOnAction', Action)
+
+SwitchCondition = switch_ns.class_('SwitchCondition', Condition)
+SwitchTurnOnTrigger = switch_ns.class_('SwitchTurnOnTrigger', Trigger.template())
+SwitchTurnOffTrigger = switch_ns.class_('SwitchTurnOffTrigger', Trigger.template())
+
+SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSwitchComponent),
+    vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_INVERTED): cv.boolean,
+    vol.Optional(CONF_ON_TURN_ON): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SwitchTurnOnTrigger),
+    }),
+    vol.Optional(CONF_ON_TURN_OFF): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SwitchTurnOffTrigger),
+    }),
+})
+
+SWITCH_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SWITCH_SCHEMA.schema)
+
+
+def setup_switch_core_(switch_var, config):
+    if CONF_INTERNAL in config:
+        add(switch_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_ICON in config:
+        add(switch_var.set_icon(config[CONF_ICON]))
+    if CONF_INVERTED in config:
+        add(switch_var.set_inverted(config[CONF_INVERTED]))
+    for conf in config.get(CONF_ON_TURN_ON, []):
+        rhs = switch_var.make_switch_turn_on_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+    for conf in config.get(CONF_ON_TURN_OFF, []):
+        rhs = switch_var.make_switch_turn_off_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+
+    setup_mqtt_component(switch_var.Pget_mqtt(), config)
+
+
+def setup_switch(switch_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        switch_obj = Pvariable(config[CONF_ID], switch_obj, has_side_effects=True)
+    CORE.add_job(setup_switch_core_, switch_obj, config)
+
+
+def register_switch(var, config):
+    switch_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_switch(switch_var))
+    CORE.add_job(setup_switch_core_, switch_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SWITCH'
+
+CONF_SWITCH_TOGGLE = 'switch.toggle'
+SWITCH_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TOGGLE, SWITCH_TOGGLE_ACTION_SCHEMA)
+def switch_toggle_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_toggle_action(template_arg)
+    type = ToggleAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SWITCH_TURN_OFF = 'switch.turn_off'
+SWITCH_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TURN_OFF, SWITCH_TURN_OFF_ACTION_SCHEMA)
+def switch_turn_off_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SWITCH_TURN_ON = 'switch.turn_on'
+SWITCH_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TURN_ON, SWITCH_TURN_ON_ACTION_SCHEMA)
+def switch_turn_on_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SWITCH_IS_ON = 'switch.is_on'
+SWITCH_IS_ON_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@CONDITION_REGISTRY.register(CONF_SWITCH_IS_ON, SWITCH_IS_ON_CONDITION_SCHEMA)
+def switch_is_on_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_switch_is_on_condition(template_arg)
+    type = SwitchCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+CONF_SWITCH_IS_OFF = 'switch.is_off'
+SWITCH_IS_OFF_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@CONDITION_REGISTRY.register(CONF_SWITCH_IS_OFF, SWITCH_IS_OFF_CONDITION_SCHEMA)
+def switch_is_off_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_switch_is_off_condition(template_arg)
+    type = SwitchCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/switch/custom.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_SWITCHES
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomSwitchConstructor = switch.switch_ns.class_('CustomSwitchConstructor')
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomSwitchConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_SWITCHES):
+        cv.ensure_list(switch.SWITCH_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(switch.Switch),
+        })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(switch.SwitchPtr)):
+        yield
+
+    rhs = CustomSwitchConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_SWITCHES]):
+        rhs = custom.Pget_switch(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        switch.register_switch(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_SWITCH'

esphome/components/switch/gpio.py

@@ -0,0 +1,50 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERLOCK, CONF_NAME, CONF_PIN, CONF_RESTORE_MODE
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+GPIOSwitch = switch.switch_ns.class_('GPIOSwitch', switch.Switch, Component)
+GPIOSwitchRestoreMode = switch.switch_ns.enum('GPIOSwitchRestoreMode')
+
+RESTORE_MODES = {
+    'RESTORE_DEFAULT_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_OFF,
+    'RESTORE_DEFAULT_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_ON,
+    'ALWAYS_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_OFF,
+    'ALWAYS_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_ON,
+}
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(GPIOSwitch),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_RESTORE_MODE): cv.one_of(*RESTORE_MODES, upper=True, space='_'),
+    vol.Optional(CONF_INTERLOCK): cv.ensure_list(cv.use_variable_id(switch.Switch)),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_gpio_switch(config[CONF_NAME], pin)
+    gpio = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_RESTORE_MODE in config:
+        add(gpio.set_restore_mode(RESTORE_MODES[config[CONF_RESTORE_MODE]]))
+
+    if CONF_INTERLOCK in config:
+        interlock = []
+        for it in config[CONF_INTERLOCK]:
+            for lock in get_variable(it):
+                yield
+            interlock.append(lock)
+        add(gpio.set_interlock(interlock))
+
+    switch.setup_switch(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_SWITCH'

esphome/components/switch/output.py

@@ -0,0 +1,28 @@
+import voluptuous as vol
+
+from esphome.components import output, switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_OUTPUT
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+OutputSwitch = switch.switch_ns.class_('OutputSwitch', switch.Switch, Component)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(OutputSwitch),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+    rhs = App.make_output_switch(config[CONF_NAME], output_)
+    switch_ = Pvariable(config[CONF_ID], rhs)
+
+    switch.setup_switch(switch_, config)
+    setup_component(switch, config)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT_SWITCH'

esphome/components/switch/remote_transmitter.py

@@ -0,0 +1,166 @@
+import voluptuous as vol
+
+from esphome.components import switch
+from esphome.components.remote_transmitter import RC_SWITCH_RAW_SCHEMA, \
+    RC_SWITCH_TYPE_A_SCHEMA, RC_SWITCH_TYPE_B_SCHEMA, RC_SWITCH_TYPE_C_SCHEMA, \
+    RC_SWITCH_TYPE_D_SCHEMA, RemoteTransmitterComponent, binary_code, build_rc_switch_protocol, \
+    remote_ns
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_CARRIER_FREQUENCY, CONF_CHANNEL, CONF_CODE, \
+    CONF_COMMAND, CONF_DATA, CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_ID, CONF_INVERTED, \
+    CONF_JVC, \
+    CONF_LG, CONF_NAME, CONF_NBITS, CONF_NEC, CONF_PANASONIC, CONF_PROTOCOL, CONF_RAW, \
+    CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B, CONF_RC_SWITCH_TYPE_C, \
+    CONF_RC_SWITCH_TYPE_D, CONF_REPEAT, CONF_SAMSUNG, CONF_SONY, CONF_STATE, CONF_TIMES, \
+    CONF_WAIT_TIME, CONF_RC5
+from esphome.cpp_generator import Pvariable, add, get_variable, progmem_array
+from esphome.cpp_types import int32
+
+DEPENDENCIES = ['remote_transmitter']
+
+REMOTE_KEYS = [CONF_JVC, CONF_NEC, CONF_LG, CONF_SAMSUNG, CONF_SONY, CONF_PANASONIC, CONF_RAW,
+               CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B,
+               CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, CONF_RC5]
+
+CONF_REMOTE_TRANSMITTER_ID = 'remote_transmitter_id'
+CONF_TRANSMITTER_ID = 'transmitter_id'
+
+RemoteTransmitter = remote_ns.class_('RemoteTransmitter', switch.Switch)
+JVCTransmitter = remote_ns.class_('JVCTransmitter', RemoteTransmitter)
+LGTransmitter = remote_ns.class_('LGTransmitter', RemoteTransmitter)
+NECTransmitter = remote_ns.class_('NECTransmitter', RemoteTransmitter)
+PanasonicTransmitter = remote_ns.class_('PanasonicTransmitter', RemoteTransmitter)
+RawTransmitter = remote_ns.class_('RawTransmitter', RemoteTransmitter)
+RC5Transmitter = remote_ns.class_('RC5Transmitter', RemoteTransmitter)
+SamsungTransmitter = remote_ns.class_('SamsungTransmitter', RemoteTransmitter)
+SonyTransmitter = remote_ns.class_('SonyTransmitter', RemoteTransmitter)
+RCSwitchRawTransmitter = remote_ns.class_('RCSwitchRawTransmitter', RemoteTransmitter)
+RCSwitchTypeATransmitter = remote_ns.class_('RCSwitchTypeATransmitter', RCSwitchRawTransmitter)
+RCSwitchTypeBTransmitter = remote_ns.class_('RCSwitchTypeBTransmitter', RCSwitchRawTransmitter)
+RCSwitchTypeCTransmitter = remote_ns.class_('RCSwitchTypeCTransmitter', RCSwitchRawTransmitter)
+RCSwitchTypeDTransmitter = remote_ns.class_('RCSwitchTypeDTransmitter', RCSwitchRawTransmitter)
+
+
+def validate_raw(value):
+    if isinstance(value, dict):
+        return cv.Schema({
+            cv.GenerateID(): cv.declare_variable_id(int32),
+            vol.Required(CONF_DATA): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
+            vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
+        })(value)
+    return validate_raw({
+        CONF_DATA: value
+    })
+
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RemoteTransmitter),
+    vol.Optional(CONF_JVC): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_LG): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): cv.one_of(28, 32, int=True),
+    }),
+    vol.Optional(CONF_NEC): cv.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint16_t,
+    }),
+    vol.Optional(CONF_SAMSUNG): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_SONY): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=12): cv.one_of(12, 15, 20, int=True),
+    }),
+    vol.Optional(CONF_PANASONIC): cv.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_RC5): cv.Schema({
+        vol.Required(CONF_ADDRESS): vol.All(cv.hex_int, vol.Range(min=0, max=0x1F)),
+        vol.Required(CONF_COMMAND): vol.All(cv.hex_int, vol.Range(min=0, max=0x3F)),
+    }),
+    vol.Optional(CONF_RAW): validate_raw,
+    vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_C): RC_SWITCH_TYPE_C_SCHEMA,
+    vol.Optional(CONF_RC_SWITCH_TYPE_D): RC_SWITCH_TYPE_D_SCHEMA,
+
+    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, cv.Schema({
+        vol.Required(CONF_TIMES): cv.positive_not_null_int,
+        vol.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds,
+    })),
+    cv.GenerateID(CONF_REMOTE_TRANSMITTER_ID): cv.use_variable_id(RemoteTransmitterComponent),
+    cv.GenerateID(CONF_TRANSMITTER_ID): cv.declare_variable_id(RemoteTransmitter),
+    vol.Optional(CONF_INVERTED): cv.invalid("Remote Transmitters do not support inverted mode!"),
+}), cv.has_exactly_one_key(*REMOTE_KEYS))
+
+
+def transmitter_base(full_config):
+    name = full_config[CONF_NAME]
+    key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)
+
+    if key == CONF_JVC:
+        return JVCTransmitter.new(name, config[CONF_DATA])
+    if key == CONF_LG:
+        return LGTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
+    if key == CONF_NEC:
+        return NECTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_PANASONIC:
+        return PanasonicTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_SAMSUNG:
+        return SamsungTransmitter.new(name, config[CONF_DATA])
+    if key == CONF_SONY:
+        return SonyTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
+    if key == CONF_RC5:
+        return RC5Transmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_RAW:
+        arr = progmem_array(config[CONF_ID], config[CONF_DATA])
+        return RawTransmitter.new(name, arr, len(config[CONF_DATA]),
+                                  config.get(CONF_CARRIER_FREQUENCY))
+    if key == CONF_RC_SWITCH_RAW:
+        return RCSwitchRawTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                          binary_code(config[CONF_CODE]), len(config[CONF_CODE]))
+    if key == CONF_RC_SWITCH_TYPE_A:
+        return RCSwitchTypeATransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                            binary_code(config[CONF_GROUP]),
+                                            binary_code(config[CONF_DEVICE]),
+                                            config[CONF_STATE])
+    if key == CONF_RC_SWITCH_TYPE_B:
+        return RCSwitchTypeBTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                            config[CONF_ADDRESS], config[CONF_CHANNEL],
+                                            config[CONF_STATE])
+    if key == CONF_RC_SWITCH_TYPE_C:
+        return RCSwitchTypeCTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                            ord(config[CONF_FAMILY][0]) - ord('a'),
+                                            config[CONF_GROUP], config[CONF_DEVICE],
+                                            config[CONF_STATE])
+    if key == CONF_RC_SWITCH_TYPE_D:
+        return RCSwitchTypeDTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
+                                            ord(config[CONF_GROUP][0]) - ord('a'),
+                                            config[CONF_DEVICE], config[CONF_STATE])
+
+    raise NotImplementedError("Unknown transmitter type {}".format(config))
+
+
+def to_code(config):
+    for remote in get_variable(config[CONF_REMOTE_TRANSMITTER_ID]):
+        yield
+    rhs = transmitter_base(config)
+    transmitter = Pvariable(config[CONF_TRANSMITTER_ID], rhs)
+
+    if CONF_REPEAT in config:
+        if isinstance(config[CONF_REPEAT], int):
+            times = config[CONF_REPEAT]
+            wait_us = 1000
+        else:
+            times = config[CONF_REPEAT][CONF_TIMES]
+            wait_us = config[CONF_REPEAT][CONF_WAIT_TIME]
+        add(transmitter.set_repeat(times, wait_us))
+
+    switch.register_switch(remote.add_transmitter(transmitter), config)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_TRANSMITTER'

esphome/components/switch/restart.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+RestartSwitch = switch.switch_ns.class_('RestartSwitch', switch.Switch)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RestartSwitch),
+    vol.Optional(CONF_INVERTED): cv.invalid("Restart switches do not support inverted mode!"),
+}))
+
+
+def to_code(config):
+    rhs = App.make_restart_switch(config[CONF_NAME])
+    restart = Pvariable(config[CONF_ID], rhs)
+    switch.setup_switch(restart, config)
+
+
+BUILD_FLAGS = '-DUSE_RESTART_SWITCH'

esphome/components/switch/shutdown.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+ShutdownSwitch = switch.switch_ns.class_('ShutdownSwitch', switch.Switch)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ShutdownSwitch),
+    vol.Optional(CONF_INVERTED): cv.invalid("Shutdown switches do not support inverted mode!"),
+}))
+
+
+def to_code(config):
+    rhs = App.make_shutdown_switch(config[CONF_NAME])
+    shutdown = Pvariable(config[CONF_ID], rhs)
+    switch.setup_switch(shutdown, config)
+
+
+BUILD_FLAGS = '-DUSE_SHUTDOWN_SWITCH'

esphome/components/switch/template.py

@@ -0,0 +1,74 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ASSUMED_STATE, CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_OPTIMISTIC, \
+    CONF_RESTORE_STATE, CONF_STATE, CONF_TURN_OFF_ACTION, CONF_TURN_ON_ACTION
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, Component, bool_, optional
+
+TemplateSwitch = switch.switch_ns.class_('TemplateSwitch', switch.Switch, Component)
+SwitchPublishAction = switch.switch_ns.class_('SwitchPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSwitch),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_ASSUMED_STATE): cv.boolean,
+    vol.Optional(CONF_TURN_OFF_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_TURN_ON_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_RESTORE_STATE): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_switch(config[CONF_NAME])
+    template = Pvariable(config[CONF_ID], rhs)
+
+    switch.setup_switch(template, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(bool_)):
+            yield
+        add(template.set_state_lambda(template_))
+    if CONF_TURN_OFF_ACTION in config:
+        automation.build_automations(template.get_turn_off_trigger(), [],
+                                     config[CONF_TURN_OFF_ACTION])
+    if CONF_TURN_ON_ACTION in config:
+        automation.build_automations(template.get_turn_on_trigger(), [],
+                                     config[CONF_TURN_ON_ACTION])
+    if CONF_OPTIMISTIC in config:
+        add(template.set_optimistic(config[CONF_OPTIMISTIC]))
+    if CONF_ASSUMED_STATE in config:
+        add(template.set_assumed_state(config[CONF_ASSUMED_STATE]))
+
+    if CONF_RESTORE_STATE in config:
+        add(template.set_restore_state(config[CONF_RESTORE_STATE]))
+
+    setup_component(template, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SWITCH'
+
+CONF_SWITCH_TEMPLATE_PUBLISH = 'switch.template.publish'
+SWITCH_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(switch.Switch),
+    vol.Required(CONF_STATE): cv.templatable(cv.boolean),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TEMPLATE_PUBLISH, SWITCH_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def switch_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_switch_publish_action(template_arg)
+    type = SwitchPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, bool_):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/switch/uart.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome.components import switch, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA, CONF_ID, CONF_INVERTED, CONF_NAME, CONF_UART_ID
+from esphome.core import HexInt
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_types import App
+from esphome.py_compat import text_type
+
+DEPENDENCIES = ['uart']
+
+UARTSwitch = switch.switch_ns.class_('UARTSwitch', switch.Switch, uart.UARTDevice)
+
+
+def validate_data(value):
+    if isinstance(value, text_type):
+        return value.encode('utf-8')
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise vol.Invalid("data must either be a string wrapped in quotes or a list of bytes")
+
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UARTSwitch),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+    vol.Required(CONF_DATA): validate_data,
+    vol.Optional(CONF_INVERTED): cv.invalid("UART switches do not support inverted mode!"),
+}))
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    data = config[CONF_DATA]
+    if isinstance(data, str):
+        data = [HexInt(ord(x)) for x in data]
+    rhs = App.make_uart_switch(uart_, config[CONF_NAME], data)
+    var = Pvariable(config[CONF_ID], rhs)
+    switch.setup_switch(var, config)
+
+
+BUILD_FLAGS = '-DUSE_UART_SWITCH'

esphome/components/text_sensor/__init__.py

@@ -0,0 +1,65 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_ON_VALUE, \
+    CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Nameable, Trigger, esphome_ns, std_string, Action
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+# pylint: disable=invalid-name
+text_sensor_ns = esphome_ns.namespace('text_sensor')
+TextSensor = text_sensor_ns.class_('TextSensor', Nameable)
+TextSensorPtr = TextSensor.operator('ptr')
+MQTTTextSensor = text_sensor_ns.class_('MQTTTextSensor', mqtt.MQTTComponent)
+
+TextSensorStateTrigger = text_sensor_ns.class_('TextSensorStateTrigger',
+                                               Trigger.template(std_string))
+TextSensorPublishAction = text_sensor_ns.class_('TextSensorPublishAction', Action)
+
+TEXT_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTTextSensor),
+    vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_ON_VALUE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(TextSensorStateTrigger),
+    }),
+})
+
+TEXT_SENSOR_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(TEXT_SENSOR_SCHEMA.schema)
+
+
+def setup_text_sensor_core_(text_sensor_var, config):
+    if CONF_INTERNAL in config:
+        add(text_sensor_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_ICON in config:
+        add(text_sensor_var.set_icon(config[CONF_ICON]))
+
+    for conf in config.get(CONF_ON_VALUE, []):
+        rhs = text_sensor_var.make_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(std_string, 'x')], conf)
+
+    setup_mqtt_component(text_sensor_var.get_mqtt(), config)
+
+
+def setup_text_sensor(text_sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        text_sensor_obj = Pvariable(config[CONF_ID], text_sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_text_sensor_core_, text_sensor_obj, config)
+
+
+def register_text_sensor(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_text_sensor(var))
+    CORE.add_job(setup_text_sensor_core_, var, config)
+
+
+BUILD_FLAGS = '-DUSE_TEXT_SENSOR'

esphome/components/text_sensor/custom.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_TEXT_SENSORS
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomTextSensorConstructor = text_sensor.text_sensor_ns.class_('CustomTextSensorConstructor')
+
+PLATFORM_SCHEMA = text_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomTextSensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_TEXT_SENSORS):
+        cv.ensure_list(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(text_sensor.TextSensor),
+        })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(text_sensor.TextSensorPtr)):
+        yield
+
+    rhs = CustomTextSensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_TEXT_SENSORS]):
+        rhs = custom.Pget_text_sensor(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        text_sensor.register_text_sensor(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_TEXT_SENSOR'

esphome/components/text_sensor/homeassistant.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['api']
+
+HomeassistantTextSensor = text_sensor.text_sensor_ns.class_('HomeassistantTextSensor',
+                                                            text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantTextSensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_text_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    sensor_ = Pvariable(config[CONF_ID], rhs)
+    text_sensor.setup_text_sensor(sensor_, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_TEXT_SENSOR'

esphome/components/text_sensor/mqtt_subscribe.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['mqtt']
+
+MQTTSubscribeTextSensor = text_sensor.text_sensor_ns.class_('MQTTSubscribeTextSensor',
+                                                            text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MQTTSubscribeTextSensor),
+    vol.Required(CONF_TOPIC): cv.subscribe_topic,
+    vol.Optional(CONF_QOS): cv.mqtt_qos,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_mqtt_subscribe_text_sensor(config[CONF_NAME], config[CONF_TOPIC])
+    sensor_ = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_QOS in config:
+        add(sensor_.set_qos(config[CONF_QOS]))
+
+    text_sensor.setup_text_sensor(sensor_, config)
+    setup_component(sensor_, config)
+
+
+BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_TEXT_SENSOR'

esphome/components/text_sensor/template.py

@@ -0,0 +1,55 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import text_sensor
+from esphome.components.text_sensor import TextSensorPublishAction
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent, optional, std_string
+
+TemplateTextSensor = text_sensor.text_sensor_ns.class_('TemplateTextSensor',
+                                                       text_sensor.TextSensor, PollingComponent)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateTextSensor),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_text_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    template = Pvariable(config[CONF_ID], rhs)
+    text_sensor.setup_text_sensor(template, config)
+    setup_component(template, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(std_string)):
+            yield
+        add(template.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_TEXT_SENSOR'
+
+CONF_TEXT_SENSOR_TEMPLATE_PUBLISH = 'text_sensor.template.publish'
+TEXT_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(text_sensor.TextSensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.string_strict),
+})
+
+
+@ACTION_REGISTRY.register(CONF_TEXT_SENSOR_TEMPLATE_PUBLISH,
+                          TEXT_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def text_sensor_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_text_sensor_publish_action(template_arg)
+    type = TextSensorPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, std_string):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/text_sensor/version.py

@@ -0,0 +1,23 @@
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+VersionTextSensor = text_sensor.text_sensor_ns.class_('VersionTextSensor',
+                                                      text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(VersionTextSensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_version_text_sensor(config[CONF_NAME])
+    sens = Pvariable(config[CONF_ID], rhs)
+    text_sensor.setup_text_sensor(sens, config)
+    setup_component(sens, config)
+
+
+BUILD_FLAGS = '-DUSE_VERSION_TEXT_SENSOR'

esphome/components/text_sensor/wifi_info.py

@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_BSSID, CONF_ID, CONF_IP_ADDRESS, CONF_NAME, CONF_SSID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['wifi']
+
+IPAddressWiFiInfo = text_sensor.text_sensor_ns.class_('IPAddressWiFiInfo',
+                                                      text_sensor.TextSensor, Component)
+SSIDWiFiInfo = text_sensor.text_sensor_ns.class_('SSIDWiFiInfo',
+                                                 text_sensor.TextSensor, Component)
+BSSIDWiFiInfo = text_sensor.text_sensor_ns.class_('BSSIDWiFiInfo',
+                                                  text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = text_sensor.PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_IP_ADDRESS): cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(IPAddressWiFiInfo),
+    })),
+    vol.Optional(CONF_SSID): cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(SSIDWiFiInfo),
+    })),
+    vol.Optional(CONF_BSSID): cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BSSIDWiFiInfo),
+    })),
+})
+
+
+def setup_conf(config, key, klass):
+    if key in config:
+        conf = config[key]
+        rhs = App.register_component(klass.new(conf[CONF_NAME]))
+        sensor_ = Pvariable(conf[CONF_ID], rhs)
+        text_sensor.register_text_sensor(sensor_, conf)
+
+
+def to_code(config):
+    setup_conf(config, CONF_IP_ADDRESS, IPAddressWiFiInfo)
+    setup_conf(config, CONF_SSID, SSIDWiFiInfo)
+    setup_conf(config, CONF_BSSID, BSSIDWiFiInfo)
+
+
+BUILD_FLAGS = '-DUSE_WIFI_INFO_TEXT_SENSOR'

esphome/components/time/__init__.py

@@ -0,0 +1,305 @@
+import datetime
+import logging
+import math
+
+import voluptuous as vol
+
+from esphome import automation
+import esphome.config_validation as cv
+from esphome.const import CONF_CRON, CONF_DAYS_OF_MONTH, CONF_DAYS_OF_WEEK, CONF_HOURS, \
+    CONF_MINUTES, CONF_MONTHS, CONF_ON_TIME, CONF_SECONDS, CONF_TIMEZONE, CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Component, Trigger, esphome_ns
+from esphome.py_compat import string_types
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+time_ns = esphome_ns.namespace('time')
+RealTimeClockComponent = time_ns.class_('RealTimeClockComponent', Component)
+CronTrigger = time_ns.class_('CronTrigger', Trigger.template(), Component)
+ESPTime = time_ns.struct('ESPTime')
+
+
+def _tz_timedelta(td):
+    offset_hour = int(td.total_seconds() / (60 * 60))
+    offset_minute = int(abs(td.total_seconds() / 60)) % 60
+    offset_second = int(abs(td.total_seconds())) % 60
+    if offset_hour == 0 and offset_minute == 0 and offset_second == 0:
+        return '0'
+    if offset_minute == 0 and offset_second == 0:
+        return '{}'.format(offset_hour)
+    if offset_second == 0:
+        return '{}:{}'.format(offset_hour, offset_minute)
+    return '{}:{}:{}'.format(offset_hour, offset_minute, offset_second)
+
+
+# https://stackoverflow.com/a/16804556/8924614
+def _week_of_month(dt):
+    first_day = dt.replace(day=1)
+    dom = dt.day
+    adjusted_dom = dom + first_day.weekday()
+    return int(math.ceil(adjusted_dom / 7.0))
+
+
+def _tz_dst_str(dt):
+    td = datetime.timedelta(hours=dt.hour, minutes=dt.minute, seconds=dt.second)
+    return 'M{}.{}.{}/{}'.format(dt.month, _week_of_month(dt), dt.isoweekday() % 7,
+                                 _tz_timedelta(td))
+
+
+def convert_tz(pytz_obj):
+    tz = pytz_obj
+
+    def _dst(dt, is_dst):
+        try:
+            return tz.dst(dt, is_dst=is_dst)
+        except TypeError:  # stupid pytz...
+            return tz.dst(dt)
+
+    def _tzname(dt, is_dst):
+        try:
+            return tz.tzname(dt, is_dst=is_dst)
+        except TypeError:  # stupid pytz...
+            return tz.tzname(dt)
+
+    def _utcoffset(dt, is_dst):
+        try:
+            return tz.utcoffset(dt, is_dst=is_dst)
+        except TypeError:  # stupid pytz...
+            return tz.utcoffset(dt)
+
+    dst_begins = None
+    dst_tzname = None
+    dst_utcoffset = None
+    dst_ends = None
+    norm_tzname = None
+    norm_utcoffset = None
+
+    hour = datetime.timedelta(hours=1)
+    this_year = datetime.datetime.now().year
+    dt = datetime.datetime(year=this_year, month=1, day=1)
+    last_dst = None
+    while dt.year == this_year:
+        current_dst = _dst(dt, not last_dst)
+        is_dst = bool(current_dst)
+        if is_dst != last_dst:
+            if is_dst:
+                dst_begins = dt
+                dst_tzname = _tzname(dt, True)
+                dst_utcoffset = _utcoffset(dt, True)
+            else:
+                dst_ends = dt + hour
+                norm_tzname = _tzname(dt, False)
+                norm_utcoffset = _utcoffset(dt, False)
+            last_dst = is_dst
+        dt += hour
+
+    tzbase = '{}{}'.format(norm_tzname, _tz_timedelta(-1 * norm_utcoffset))
+    if dst_begins is None:
+        # No DST in this timezone
+        _LOGGER.info("Detected timezone '%s' with UTC offset %s",
+                     norm_tzname, _tz_timedelta(norm_utcoffset))
+        return tzbase
+    tzext = '{}{},{},{}'.format(dst_tzname, _tz_timedelta(-1 * dst_utcoffset),
+                                _tz_dst_str(dst_begins), _tz_dst_str(dst_ends))
+    _LOGGER.info("Detected timezone '%s' with UTC offset %s and daylight savings time from "
+                 "%s to %s",
+                 norm_tzname, _tz_timedelta(norm_utcoffset), dst_begins.strftime("%x %X"),
+                 dst_ends.strftime("%x %X"))
+    return tzbase + tzext
+
+
+def detect_tz():
+    try:
+        import tzlocal
+        import pytz
+    except ImportError:
+        raise vol.Invalid("No timezone specified and 'tzlocal' not installed. To automatically "
+                          "detect the timezone please install tzlocal (pip install tzlocal)")
+    try:
+        tz = tzlocal.get_localzone()
+    except pytz.exceptions.UnknownTimeZoneError:
+        _LOGGER.warning("Could not auto-detect timezone. Using UTC...")
+        return 'UTC'
+
+    return convert_tz(tz)
+
+
+def _parse_cron_int(value, special_mapping, message):
+    special_mapping = special_mapping or {}
+    if isinstance(value, string_types) and value in special_mapping:
+        return special_mapping[value]
+    try:
+        return int(value)
+    except ValueError:
+        raise vol.Invalid(message.format(value))
+
+
+def _parse_cron_part(part, min_value, max_value, special_mapping):
+    if part in ('*', '?'):
+        return set(x for x in range(min_value, max_value + 1))
+    if '/' in part:
+        data = part.split('/')
+        if len(data) > 2:
+            raise vol.Invalid(u"Can't have more than two '/' in one time expression, got {}"
+                              .format(part))
+        offset, repeat = data
+        offset_n = 0
+        if offset:
+            offset_n = _parse_cron_int(offset, special_mapping,
+                                       u"Offset for '/' time expression must be an integer, got {}")
+
+        try:
+            repeat_n = int(repeat)
+        except ValueError:
+            raise vol.Invalid(u"Repeat for '/' time expression must be an integer, got {}"
+                              .format(repeat))
+        return set(x for x in range(offset_n, max_value + 1, repeat_n))
+    if '-' in part:
+        data = part.split('-')
+        if len(data) > 2:
+            raise vol.Invalid(u"Can't have more than two '-' in range time expression '{}'"
+                              .format(part))
+        begin, end = data
+        begin_n = _parse_cron_int(begin, special_mapping, u"Number for time range must be integer, "
+                                                          u"got {}")
+        end_n = _parse_cron_int(end, special_mapping, u"Number for time range must be integer, "
+                                                      u"got {}")
+        if end_n < begin_n:
+            return set(x for x in range(end_n, max_value + 1)) | \
+                   set(x for x in range(min_value, begin_n + 1))
+        return set(x for x in range(begin_n, end_n + 1))
+
+    return {_parse_cron_int(part, special_mapping, u"Number for time expression must be an "
+                                                   u"integer, got {}")}
+
+
+def cron_expression_validator(name, min_value, max_value, special_mapping=None):
+    def validator(value):
+        if isinstance(value, list):
+            for v in value:
+                if not isinstance(v, int):
+                    raise vol.Invalid(
+                        "Expected integer for {} '{}', got {}".format(v, name, type(v)))
+                if v < min_value or v > max_value:
+                    raise vol.Invalid(
+                        "{} {} is out of range (min={} max={}).".format(name, v, min_value,
+                                                                        max_value))
+            return list(sorted(value))
+        value = cv.string(value)
+        values = set()
+        for part in value.split(','):
+            values |= _parse_cron_part(part, min_value, max_value, special_mapping)
+        return validator(list(values))
+
+    return validator
+
+
+validate_cron_seconds = cron_expression_validator('seconds', 0, 60)
+validate_cron_minutes = cron_expression_validator('minutes', 0, 59)
+validate_cron_hours = cron_expression_validator('hours', 0, 23)
+validate_cron_days_of_month = cron_expression_validator('days of month', 1, 31)
+validate_cron_months = cron_expression_validator('months', 1, 12, {
+    'JAN': 1, 'FEB': 2, 'MAR': 3, 'APR': 4, 'MAY': 5, 'JUN': 6, 'JUL': 7, 'AUG': 8,
+    'SEP': 9, 'OCT': 10, 'NOV': 11, 'DEC': 12
+})
+validate_cron_days_of_week = cron_expression_validator('days of week', 1, 7, {
+    'SUN': 1, 'MON': 2, 'TUE': 3, 'WED': 4, 'THU': 5, 'FRI': 6, 'SAT': 7
+})
+CRON_KEYS = [CONF_SECONDS, CONF_MINUTES, CONF_HOURS, CONF_DAYS_OF_MONTH, CONF_MONTHS,
+             CONF_DAYS_OF_WEEK]
+
+
+def validate_cron_raw(value):
+    value = cv.string(value)
+    value = value.split(' ')
+    if len(value) != 6:
+        raise vol.Invalid("Cron expression must consist of exactly 6 space-separated parts, "
+                          "not {}".format(len(value)))
+    seconds, minutes, hours, days_of_month, months, days_of_week = value
+    return {
+        CONF_SECONDS: validate_cron_seconds(seconds),
+        CONF_MINUTES: validate_cron_minutes(minutes),
+        CONF_HOURS: validate_cron_hours(hours),
+        CONF_DAYS_OF_MONTH: validate_cron_days_of_month(days_of_month),
+        CONF_MONTHS: validate_cron_months(months),
+        CONF_DAYS_OF_WEEK: validate_cron_days_of_week(days_of_week),
+    }
+
+
+def validate_cron_keys(value):
+    if CONF_CRON in value:
+        for key in value.keys():
+            if key in CRON_KEYS:
+                raise vol.Invalid("Cannot use option {} when cron: is specified.".format(key))
+        cron_ = value[CONF_CRON]
+        value = {x: value[x] for x in value if x != CONF_CRON}
+        value.update(cron_)
+        return value
+    return cv.has_at_least_one_key(*CRON_KEYS)(value)
+
+
+def validate_tz(value):
+    value = cv.string_strict(value)
+
+    try:
+        import pytz
+
+        return convert_tz(pytz.timezone(value))
+    except Exception:  # pylint: disable=broad-except
+        return value
+
+
+TIME_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_TIMEZONE, default=detect_tz): validate_tz,
+    vol.Optional(CONF_ON_TIME): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(CronTrigger),
+        vol.Optional(CONF_SECONDS): validate_cron_seconds,
+        vol.Optional(CONF_MINUTES): validate_cron_minutes,
+        vol.Optional(CONF_HOURS): validate_cron_hours,
+        vol.Optional(CONF_DAYS_OF_MONTH): validate_cron_days_of_month,
+        vol.Optional(CONF_MONTHS): validate_cron_months,
+        vol.Optional(CONF_DAYS_OF_WEEK): validate_cron_days_of_week,
+        vol.Optional(CONF_CRON): validate_cron_raw,
+    }, validate_cron_keys),
+})
+
+
+def setup_time_core_(time_var, config):
+    add(time_var.set_timezone(config[CONF_TIMEZONE]))
+
+    for conf in config.get(CONF_ON_TIME, []):
+        rhs = App.register_component(time_var.Pmake_cron_trigger())
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+
+        seconds = conf.get(CONF_SECONDS, [x for x in range(0, 61)])
+        add(trigger.add_seconds(seconds))
+
+        minutes = conf.get(CONF_MINUTES, [x for x in range(0, 60)])
+        add(trigger.add_minutes(minutes))
+
+        hours = conf.get(CONF_HOURS, [x for x in range(0, 24)])
+        add(trigger.add_hours(hours))
+
+        days_of_month = conf.get(CONF_DAYS_OF_MONTH, [x for x in range(1, 32)])
+        add(trigger.add_days_of_month(days_of_month))
+
+        months = conf.get(CONF_MONTHS, [x for x in range(1, 13)])
+        add(trigger.add_months(months))
+
+        days_of_week = conf.get(CONF_DAYS_OF_WEEK, [x for x in range(1, 8)])
+        add(trigger.add_days_of_week(days_of_week))
+
+        automation.build_automations(trigger, [], conf)
+
+
+def setup_time(time_var, config):
+    CORE.add_job(setup_time_core_, time_var, config)
+
+
+BUILD_FLAGS = '-DUSE_TIME'

esphome/components/time/homeassistant.py

@@ -0,0 +1,24 @@
+from esphome.components import time as time_
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeAssistantTime = time_.time_ns.class_('HomeAssistantTime', time_.RealTimeClockComponent)
+
+PLATFORM_SCHEMA = time_.TIME_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeAssistantTime),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_time_component()
+    ha_time = Pvariable(config[CONF_ID], rhs)
+    time_.setup_time(ha_time, config)
+    setup_component(ha_time, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_TIME'

esphome/components/time/sntp.py

@@ -0,0 +1,30 @@
+import voluptuous as vol
+
+from esphome.components import time as time_
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_SERVERS
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+SNTPComponent = time_.time_ns.class_('SNTPComponent', time_.RealTimeClockComponent)
+
+PLATFORM_SCHEMA = time_.TIME_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SNTPComponent),
+    vol.Optional(CONF_SERVERS): vol.All(cv.ensure_list(cv.domain), vol.Length(min=1, max=3)),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_sntp_component()
+    sntp = Pvariable(config[CONF_ID], rhs)
+    if CONF_SERVERS in config:
+        servers = config[CONF_SERVERS]
+        servers += [''] * (3 - len(servers))
+        add(sntp.set_servers(*servers))
+
+    time_.setup_time(sntp, config)
+    setup_component(sntp, config)
+
+
+BUILD_FLAGS = '-DUSE_SNTP_COMPONENT'

esphome/components/uart.py

@@ -0,0 +1,43 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_RX_PIN, CONF_TX_PIN
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+UARTComponent = esphome_ns.class_('UARTComponent', Component)
+UARTDevice = esphome_ns.class_('UARTDevice')
+MULTI_CONF = True
+
+
+def validate_rx_pin(value):
+    value = pins.input_pin(value)
+    if CORE.is_esp8266 and value >= 16:
+        raise vol.Invalid("Pins GPIO16 and GPIO17 cannot be used as RX pins on ESP8266.")
+    return value
+
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(UARTComponent),
+    vol.Optional(CONF_TX_PIN): pins.output_pin,
+    vol.Optional(CONF_RX_PIN): validate_rx_pin,
+    vol.Required(CONF_BAUD_RATE): cv.positive_int,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN))
+
+
+def to_code(config):
+    rhs = App.init_uart(config[CONF_BAUD_RATE])
+    var = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_TX_PIN in config:
+        add(var.set_tx_pin(config[CONF_TX_PIN]))
+    if CONF_RX_PIN in config:
+        add(var.set_rx_pin(config[CONF_RX_PIN]))
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_UART'

esphome/components/web_server.py

@@ -0,0 +1,39 @@
+import voluptuous as vol
+
+import esphome.config_validation as cv
+from esphome.const import CONF_CSS_URL, CONF_ID, CONF_JS_URL, CONF_PORT
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, StoringController, esphome_ns
+
+WebServer = esphome_ns.class_('WebServer', Component, StoringController)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(WebServer),
+    vol.Optional(CONF_PORT): cv.port,
+    vol.Optional(CONF_CSS_URL): cv.string,
+    vol.Optional(CONF_JS_URL): cv.string,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.init_web_server(config.get(CONF_PORT))
+    web_server = Pvariable(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]))
+
+    setup_component(web_server, config)
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_WEB_SERVER'
+
+
+def lib_deps(config):
+    deps = []
+    if CORE.is_esp32:
+        deps.append('FS')
+    deps.append('ESP Async WebServer@1.1.1')
+    return deps

esphome/components/wifi.py

@@ -0,0 +1,203 @@
+import voluptuous as vol
+
+from esphome.automation import CONDITION_REGISTRY, Condition
+import esphome.config_validation as cv
+from esphome.const import CONF_AP, CONF_BSSID, CONF_CHANNEL, CONF_DNS1, CONF_DNS2, CONF_DOMAIN, \
+    CONF_FAST_CONNECT, CONF_GATEWAY, CONF_HIDDEN, CONF_ID, CONF_MANUAL_IP, CONF_NETWORKS, \
+    CONF_PASSWORD, CONF_POWER_SAVE_MODE, CONF_REBOOT_TIMEOUT, CONF_SSID, CONF_STATIC_IP, \
+    CONF_SUBNET, CONF_USE_ADDRESS
+from esphome.core import CORE, HexInt
+from esphome.cpp_generator import Pvariable, StructInitializer, add, variable
+from esphome.cpp_types import App, Component, esphome_ns, global_ns
+
+IPAddress = global_ns.class_('IPAddress')
+ManualIP = esphome_ns.struct('ManualIP')
+WiFiComponent = esphome_ns.class_('WiFiComponent', Component)
+WiFiAP = esphome_ns.struct('WiFiAP')
+
+WiFiPowerSaveMode = esphome_ns.enum('WiFiPowerSaveMode')
+WIFI_POWER_SAVE_MODES = {
+    'NONE': WiFiPowerSaveMode.WIFI_POWER_SAVE_NONE,
+    'LIGHT': WiFiPowerSaveMode.WIFI_POWER_SAVE_LIGHT,
+    'HIGH': WiFiPowerSaveMode.WIFI_POWER_SAVE_HIGH,
+}
+WiFiConnectedCondition = esphome_ns.class_('WiFiConnectedCondition', Condition)
+
+
+def validate_password(value):
+    value = cv.string_strict(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) > 64:
+        raise vol.Invalid(u"WPA password must be at most 64 characters long")
+    return value
+
+
+def validate_channel(value):
+    value = cv.positive_int(value)
+    if value < 1:
+        raise vol.Invalid("Minimum WiFi channel is 1")
+    if value > 14:
+        raise vol.Invalid("Maximum WiFi channel is 14")
+    return value
+
+
+AP_MANUAL_IP_SCHEMA = cv.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.Optional(CONF_DNS1, default="1.1.1.1"): cv.ipv4,
+    vol.Optional(CONF_DNS2, default="1.0.0.1"): cv.ipv4,
+})
+
+WIFI_NETWORK_BASE = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(WiFiAP),
+    vol.Optional(CONF_SSID): cv.ssid,
+    vol.Optional(CONF_PASSWORD): validate_password,
+    vol.Optional(CONF_CHANNEL): validate_channel,
+    vol.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
+})
+
+WIFI_NETWORK_AP = WIFI_NETWORK_BASE.extend({
+
+})
+
+WIFI_NETWORK_STA = WIFI_NETWORK_BASE.extend({
+    vol.Optional(CONF_BSSID): cv.mac_address,
+    vol.Optional(CONF_HIDDEN): cv.boolean,
+})
+
+
+def validate(config):
+    if CONF_PASSWORD in config and CONF_SSID not in config:
+        raise vol.Invalid("Cannot have WiFi password without SSID!")
+
+    if CONF_SSID in config:
+        network = {CONF_SSID: config.pop(CONF_SSID)}
+        if CONF_PASSWORD in config:
+            network[CONF_PASSWORD] = config.pop(CONF_PASSWORD)
+        if CONF_NETWORKS in config:
+            raise vol.Invalid("You cannot use the 'ssid:' option together with 'networks:'. Please "
+                              "copy your network into the 'networks:' key")
+        config[CONF_NETWORKS] = cv.ensure_list(WIFI_NETWORK_STA)(network)
+
+    if (CONF_NETWORKS not in config) and (CONF_AP not in config):
+        raise vol.Invalid("Please specify at least an SSID or an Access Point "
+                          "to create.")
+
+    if config.get(CONF_FAST_CONNECT, False):
+        networks = config.get(CONF_NETWORKS, [])
+        if not networks:
+            raise vol.Invalid("At least one network required for fast_connect!")
+        if len(networks) != 1:
+            raise vol.Invalid("Fast connect can only be used with one network!")
+
+    if CONF_USE_ADDRESS not in config:
+        if CONF_MANUAL_IP in config:
+            use_address = str(config[CONF_MANUAL_IP][CONF_STATIC_IP])
+        else:
+            use_address = CORE.name + config[CONF_DOMAIN]
+        config[CONF_USE_ADDRESS] = use_address
+
+    return config
+
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(WiFiComponent),
+    vol.Optional(CONF_NETWORKS): cv.ensure_list(WIFI_NETWORK_STA),
+
+    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): WIFI_NETWORK_AP,
+    vol.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
+    vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SAVE_MODE): cv.one_of(*WIFI_POWER_SAVE_MODES, upper=True),
+    vol.Optional(CONF_FAST_CONNECT): cv.boolean,
+    vol.Optional(CONF_USE_ADDRESS): cv.string_strict,
+
+    vol.Optional('hostname'): cv.invalid("The hostname option has been removed in 1.11.0"),
+}), validate)
+
+
+def safe_ip(ip):
+    if ip is None:
+        return IPAddress(0, 0, 0, 0)
+    return IPAddress(*ip.args)
+
+
+def manual_ip(config):
+    if config is None:
+        return None
+    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 wifi_network(config, static_ip):
+    ap = variable(config[CONF_ID], WiFiAP())
+    if CONF_SSID in config:
+        add(ap.set_ssid(config[CONF_SSID]))
+    if CONF_PASSWORD in config:
+        add(ap.set_password(config[CONF_PASSWORD]))
+    if CONF_BSSID in config:
+        add(ap.set_bssid([HexInt(i) for i in config[CONF_BSSID].parts]))
+    if CONF_HIDDEN in config:
+        add(ap.set_hidden(config[CONF_HIDDEN]))
+    if CONF_CHANNEL in config:
+        add(ap.set_channel(config[CONF_CHANNEL]))
+    if static_ip is not None:
+        add(ap.set_manual_ip(manual_ip(static_ip)))
+
+    return ap
+
+
+def to_code(config):
+    rhs = App.init_wifi()
+    wifi = Pvariable(config[CONF_ID], rhs)
+    add(wifi.set_use_address(config[CONF_USE_ADDRESS]))
+
+    for network in config.get(CONF_NETWORKS, []):
+        add(wifi.add_sta(wifi_network(network, config.get(CONF_MANUAL_IP))))
+
+    if CONF_AP in config:
+        add(wifi.set_ap(wifi_network(config[CONF_AP], config.get(CONF_MANUAL_IP))))
+
+    if CONF_REBOOT_TIMEOUT in config:
+        add(wifi.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+
+    if CONF_POWER_SAVE_MODE in config:
+        add(wifi.set_power_save_mode(WIFI_POWER_SAVE_MODES[config[CONF_POWER_SAVE_MODE]]))
+
+    if CONF_FAST_CONNECT in config:
+        add(wifi.set_fast_connect(config[CONF_FAST_CONNECT]))
+
+
+def lib_deps(config):
+    if CORE.is_esp8266:
+        return 'ESP8266WiFi'
+    if CORE.is_esp32:
+        return None
+    raise NotImplementedError
+
+
+CONF_WIFI_CONNECTED = 'wifi.connected'
+WIFI_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
+
+
+@CONDITION_REGISTRY.register(CONF_WIFI_CONNECTED, WIFI_CONNECTED_CONDITION_SCHEMA)
+def wifi_connected_to_code(config, condition_id, template_arg, args):
+    rhs = WiFiConnectedCondition.new(template_arg)
+    type = WiFiConnectedCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/config.py

@@ -0,0 +1,613 @@
+from __future__ import print_function
+
+from collections import OrderedDict
+import importlib
+import logging
+import re
+
+import voluptuous as vol
+
+from esphome import core, core_config, yaml_util
+from esphome.components import substitutions
+from esphome.const import CONF_ESPHOME, CONF_PLATFORM, ESP_PLATFORMS
+from esphome.core import CORE, EsphomeError
+from esphome.helpers import color, indent
+from esphome.py_compat import text_type
+from esphome.util import safe_print
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import List, Optional, Tuple, Union  # noqa
+from esphome.core import ConfigType  # noqa
+from esphome.yaml_util import is_secret
+from esphome.voluptuous_schema import ExtraKeysInvalid
+
+_LOGGER = logging.getLogger(__name__)
+
+_COMPONENT_CACHE = {}
+
+
+def get_component(domain):
+    if domain in _COMPONENT_CACHE:
+        return _COMPONENT_CACHE[domain]
+
+    path = 'esphome.components.{}'.format(domain)
+    try:
+        module = importlib.import_module(path)
+    except (ImportError, ValueError) as err:
+        _LOGGER.debug(err)
+    else:
+        _COMPONENT_CACHE[domain] = module
+        return module
+
+    _LOGGER.error("Unable to find component %s", domain)
+    return None
+
+
+def get_platform(domain, platform):
+    return get_component("{}.{}".format(domain, platform))
+
+
+def is_platform_component(component):
+    return hasattr(component, 'PLATFORM_SCHEMA')
+
+
+def iter_components(config):
+    for domain, conf in config.items():
+        if domain == CONF_ESPHOME:
+            yield CONF_ESPHOME, core_config, conf
+            continue
+        component = get_component(domain)
+        if getattr(component, 'MULTI_CONF', False):
+            for conf_ in conf:
+                yield domain, component, conf_
+        else:
+            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
+
+
+ConfigPath = List[Union[str, int]]
+
+
+def _path_begins_with_(path, other):  # type: (ConfigPath, ConfigPath) -> bool
+    if len(path) < len(other):
+        return False
+    return path[:len(other)] == other
+
+
+def _path_begins_with(path, other):  # type: (ConfigPath, ConfigPath) -> bool
+    ret = _path_begins_with_(path, other)
+    return ret
+
+
+class Config(OrderedDict):
+    def __init__(self):
+        super(Config, self).__init__()
+        self.errors = []  # type: List[Tuple[basestring, ConfigPath]]
+        self.domains = []  # type: List[Tuple[ConfigPath, basestring]]
+
+    def add_error(self, message, path):
+        # type: (basestring, ConfigPath) -> None
+        if not isinstance(message, text_type):
+            message = text_type(message)
+        self.errors.append((message, path))
+
+    def add_domain(self, path, name):
+        # type: (ConfigPath, basestring) -> None
+        self.domains.append((path, name))
+
+    def remove_domain(self, path, name):
+        self.domains.remove((path, name))
+
+    def lookup_domain(self, path):
+        # type: (ConfigPath) -> Optional[basestring]
+        best_len = 0
+        best_domain = None
+        for d_path, domain in self.domains:
+            if len(d_path) < best_len:
+                continue
+            if _path_begins_with(path, d_path):
+                best_len = len(d_path)
+                best_domain = domain
+        return best_domain
+
+    def is_in_error_path(self, path):
+        for _, p in self.errors:
+            if _path_begins_with(p, path):
+                return True
+        return False
+
+    def get_error_for_path(self, path):
+        for msg, p in self.errors:
+            if self.nested_item_path(p) == path:
+                return msg
+        return None
+
+    def nested_item(self, path):
+        data = self
+        for item_index in path:
+            try:
+                data = data[item_index]
+            except (KeyError, IndexError, TypeError):
+                return {}
+        return data
+
+    def nested_item_path(self, path):
+        data = self
+        part = []
+        for item_index in path:
+            try:
+                data = data[item_index]
+            except (KeyError, IndexError, TypeError):
+                return part
+            part.append(item_index)
+        return part
+
+
+def iter_ids(config, path=None):
+    path = path or []
+    if isinstance(config, core.ID):
+        yield config, path
+    elif isinstance(config, core.Lambda):
+        for id in config.requires_ids:
+            yield id, path
+    elif isinstance(config, list):
+        for i, item in enumerate(config):
+            for result in iter_ids(item, path + [i]):
+                yield result
+    elif isinstance(config, dict):
+        for key, value in config.items():
+            for result in iter_ids(value, path + [key]):
+                yield result
+
+
+def do_id_pass(result):  # type: (Config) -> None
+    from esphome.cpp_generator import MockObjClass
+
+    declare_ids = []  # type: List[Tuple[core.ID, ConfigPath]]
+    searching_ids = []  # type: List[Tuple[core.ID, ConfigPath]]
+    for id, path in iter_ids(result):
+        if id.is_declaration:
+            if id.id is not None and any(v[0].id == id.id for v in declare_ids):
+                result.add_error(u"ID {} redefined!".format(id.id), path)
+                continue
+            declare_ids.append((id, path))
+        else:
+            searching_ids.append((id, path))
+    # Resolve default ids after manual IDs
+    for id, _ in declare_ids:
+        id.resolve([v[0].id for v in declare_ids])
+
+    # Check searched IDs
+    for id, path in searching_ids:
+        if id.id is not None:
+            # manually declared
+            match = next((v[0] for v in declare_ids if v[0].id == id.id), None)
+            if match is None:
+                # No declared ID with this name
+                result.add_error("Couldn't find ID '{}'".format(id.id), path)
+                continue
+            if not isinstance(match.type, MockObjClass) or not isinstance(id.type, MockObjClass):
+                continue
+            if not match.type.inherits_from(id.type):
+                result.add_error("ID '{}' of type {} doesn't inherit from {}. Please double check "
+                                 "your ID is pointing to the correct value"
+                                 "".format(id.id, match.type, id.type), path)
+
+        if id.id is None and id.type is not None:
+            for v in declare_ids:
+                if v[0] is None or not isinstance(v[0].type, MockObjClass):
+                    continue
+                inherits = v[0].type.inherits_from(id.type)
+                if inherits:
+                    id.id = v[0].id
+                    break
+            else:
+                result.add_error("Couldn't resolve ID for type '{}'".format(id.type), path)
+
+
+def validate_config(config):
+    result = Config()
+
+    def _comp_error(ex, path):
+        # type: (vol.Invalid, List[basestring]) -> None
+        if isinstance(ex, vol.MultipleInvalid):
+            errors = ex.errors
+        else:
+            errors = [ex]
+
+        for e in errors:
+            path_ = path + e.path
+            domain = result.lookup_domain(path_) or ''
+            result.add_error(_format_vol_invalid(e, config, path, domain), path_)
+
+    skip_paths = list()  # type: List[ConfigPath]
+
+    # Step 1: Load everything
+    result.add_domain([CONF_ESPHOME], CONF_ESPHOME)
+    result[CONF_ESPHOME] = config[CONF_ESPHOME]
+
+    for domain, conf in config.items():
+        domain = str(domain)
+        if domain == CONF_ESPHOME or domain.startswith(u'.'):
+            skip_paths.append([domain])
+            continue
+        result.add_domain([domain], domain)
+        result[domain] = conf
+        if conf is None:
+            result[domain] = conf = {}
+        component = get_component(domain)
+        if component is None:
+            result.add_error(u"Component not found: {}".format(domain), [domain])
+            skip_paths.append([domain])
+            continue
+
+        if not isinstance(conf, list) and getattr(component, 'MULTI_CONF', False):
+            result[domain] = conf = [conf]
+
+        success = True
+        dependencies = getattr(component, 'DEPENDENCIES', [])
+        for dependency in dependencies:
+            if dependency not in config:
+                result.add_error(u"Component {} requires component {}".format(domain, dependency),
+                                 [domain])
+                success = False
+        if not success:
+            skip_paths.append([domain])
+            continue
+
+        success = True
+        conflicts_with = getattr(component, 'CONFLICTS_WITH', [])
+        for conflict in conflicts_with:
+            if conflict in config:
+                result.add_error(u"Component {} cannot be used together with component {}"
+                                 u"".format(domain, conflict), [domain])
+                success = False
+        if not success:
+            skip_paths.append([domain])
+            continue
+
+        esp_platforms = getattr(component, 'ESP_PLATFORMS', ESP_PLATFORMS)
+        if CORE.esp_platform not in esp_platforms:
+            result.add_error(u"Component {} doesn't support {}.".format(domain, CORE.esp_platform),
+                             [domain])
+            skip_paths.append([domain])
+            continue
+
+        if not hasattr(component, 'PLATFORM_SCHEMA'):
+            continue
+
+        result.remove_domain([domain], domain)
+
+        if not isinstance(conf, list) and conf:
+            result[domain] = conf = [conf]
+
+        for i, p_config in enumerate(conf):
+            if not isinstance(p_config, dict):
+                result.add_error(u"Platform schemas must have 'platform:' key", [domain, i])
+                skip_paths.append([domain, i])
+                continue
+            p_name = p_config.get('platform')
+            if p_name is None:
+                result.add_error(u"No platform specified for {}".format(domain), [domain, i])
+                skip_paths.append([domain, i])
+                continue
+            p_domain = u'{}.{}'.format(domain, p_name)
+            result.add_domain([domain, i], p_domain)
+            platform = get_platform(domain, p_name)
+            if platform is None:
+                result.add_error(u"Platform not found: '{}'".format(p_domain), [domain, i])
+                skip_paths.append([domain, i])
+                continue
+
+            success = True
+            dependencies = getattr(platform, 'DEPENDENCIES', [])
+            for dependency in dependencies:
+                if dependency not in config:
+                    result.add_error(u"Platform {} requires component {}"
+                                     u"".format(p_domain, dependency), [domain, i])
+                    success = False
+            if not success:
+                skip_paths.append([domain, i])
+                continue
+
+            success = True
+            conflicts_with = getattr(platform, 'CONFLICTS_WITH', [])
+            for conflict in conflicts_with:
+                if conflict in config:
+                    result.add_error(u"Platform {} cannot be used together with component {}"
+                                     u"".format(p_domain, conflict), [domain, i])
+                    success = False
+            if not success:
+                skip_paths.append([domain, i])
+                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 {}."
+                                 u"".format(p_domain, CORE.esp_platform), [domain, i])
+                skip_paths.append([domain, i])
+                continue
+
+    # Step 2: Validate configuration
+    try:
+        result[CONF_ESPHOME] = core_config.CONFIG_SCHEMA(result[CONF_ESPHOME])
+    except vol.Invalid as ex:
+        _comp_error(ex, [CONF_ESPHOME])
+
+    for domain, conf in result.items():
+        domain = str(domain)
+        if [domain] in skip_paths:
+            continue
+        component = get_component(domain)
+
+        if hasattr(component, 'CONFIG_SCHEMA'):
+            multi_conf = getattr(component, 'MULTI_CONF', False)
+
+            if multi_conf:
+                for i, conf_ in enumerate(conf):
+                    try:
+                        validated = component.CONFIG_SCHEMA(conf_)
+                        result[domain][i] = validated
+                    except vol.Invalid as ex:
+                        _comp_error(ex, [domain, i])
+            else:
+                try:
+                    validated = component.CONFIG_SCHEMA(conf)
+                    result[domain] = validated
+                except vol.Invalid as ex:
+                    _comp_error(ex, [domain])
+                    continue
+
+        if not hasattr(component, 'PLATFORM_SCHEMA'):
+            continue
+
+        for i, p_config in enumerate(conf):
+            if [domain, i] in skip_paths:
+                continue
+            p_name = p_config['platform']
+            platform = get_platform(domain, p_name)
+
+            if hasattr(platform, 'PLATFORM_SCHEMA'):
+                try:
+                    p_validated = platform.PLATFORM_SCHEMA(p_config)
+                except vol.Invalid as ex:
+                    _comp_error(ex, [domain, i])
+                    continue
+                result[domain][i] = p_validated
+
+    if not result.errors:
+        # Only parse IDs if no validation error. Otherwise
+        # user gets confusing messages
+        do_id_pass(result)
+    return result
+
+
+def _nested_getitem(data, path):
+    for item_index in path:
+        try:
+            data = data[item_index]
+        except (KeyError, IndexError, TypeError):
+            return None
+    return data
+
+
+def humanize_error(config, validation_error):
+    offending_item_summary = _nested_getitem(config, validation_error.path)
+    if isinstance(offending_item_summary, dict):
+        offending_item_summary = None
+    validation_error = text_type(validation_error)
+    m = re.match(r'^(.*?)\s*(?:for dictionary value )?@ data\[.*$', validation_error)
+    if m is not None:
+        validation_error = m.group(1)
+    validation_error = validation_error.strip()
+    if not validation_error.endswith(u'.'):
+        validation_error += u'.'
+    if offending_item_summary is None or is_secret(offending_item_summary):
+        return validation_error
+
+    return u"{} Got '{}'".format(validation_error, offending_item_summary)
+
+
+def _format_vol_invalid(ex, config, path, domain):
+    # type: (vol.Invalid, ConfigType, ConfigPath, basestring) -> unicode
+    message = u''
+    try:
+        paren = ex.path[-2]
+    except IndexError:
+        paren = domain
+
+    if isinstance(ex, ExtraKeysInvalid):
+        if ex.candidates:
+            message += u'[{}] is an invalid option for [{}]. Did you mean {}?'.format(
+                ex.path[-1], paren, u', '.join(u'[{}]'.format(x) for x in ex.candidates))
+        else:
+            message += u'[{}] is an invalid option for [{}]. Please check the indentation.'.format(
+                ex.path[-1], paren)
+    elif u'extra keys not allowed' in ex.error_message:
+        message += u'[{}] is an invalid option for [{}].'.format(ex.path[-1], paren)
+    elif u'required key not provided' in ex.error_message:
+        message += u"'{}' is a required option for [{}].".format(ex.path[-1], paren)
+    else:
+        message += humanize_error(_nested_getitem(config, path), ex)
+
+    return message
+
+
+def load_config():
+    try:
+        config = yaml_util.load_yaml(CORE.config_path)
+    except OSError:
+        raise EsphomeError(u"Invalid YAML at {}. Please see YAML syntax reference or use an online "
+                           u"YAML syntax validator".format(CORE.config_path))
+    CORE.raw_config = config
+    config = substitutions.do_substitution_pass(config)
+    core_config.preload_core_config(config)
+
+    try:
+        result = validate_config(config)
+    except EsphomeError:
+        raise
+    except Exception:
+        _LOGGER.error(u"Unexpected exception while reading configuration:")
+        raise
+
+    return result
+
+
+def line_info(obj, highlight=True):
+    """Display line config source."""
+    if not highlight:
+        return None
+    if hasattr(obj, '__config_file__'):
+        return color('cyan', "[source {}:{}]"
+                     .format(obj.__config_file__, obj.__line__ or '?'))
+    return None
+
+
+def _print_on_next_line(obj):
+    if isinstance(obj, (list, tuple, dict)):
+        return True
+    if isinstance(obj, str):
+        return len(obj) > 80
+    if isinstance(obj, core.Lambda):
+        return len(obj.value) > 80
+    return False
+
+
+def dump_dict(config, path, at_root=True):
+    # type: (Config, ConfigPath, bool) -> Tuple[unicode, bool]
+    conf = config.nested_item(path)
+    ret = u''
+    multiline = False
+
+    if at_root:
+        error = config.get_error_for_path(path)
+        if error is not None:
+            ret += u'\n' + color('bold_red', error) + u'\n'
+
+    if isinstance(conf, (list, tuple)):
+        multiline = True
+        if not conf:
+            ret += u'[]'
+            multiline = False
+
+        for i in range(len(conf)):
+            path_ = path + [i]
+            error = config.get_error_for_path(path_)
+            if error is not None:
+                ret += u'\n' + color('bold_red', error) + u'\n'
+
+            sep = u'- '
+            if config.is_in_error_path(path_):
+                sep = color('red', sep)
+            msg, _ = dump_dict(config, path_, at_root=False)
+            msg = indent(msg)
+            inf = line_info(config.nested_item(path_), highlight=config.is_in_error_path(path_))
+            if inf is not None:
+                msg = inf + u'\n' + msg
+            elif msg:
+                msg = msg[2:]
+            ret += sep + msg + u'\n'
+    elif isinstance(conf, dict):
+        multiline = True
+        if not conf:
+            ret += u'{}'
+            multiline = False
+
+        for k in conf.keys():
+            path_ = path + [k]
+            error = config.get_error_for_path(path_)
+            if error is not None:
+                ret += u'\n' + color('bold_red', error) + u'\n'
+
+            st = u'{}: '.format(k)
+            if config.is_in_error_path(path_):
+                st = color('red', st)
+            msg, m = dump_dict(config, path_, at_root=False)
+
+            inf = line_info(config.nested_item(path_), highlight=config.is_in_error_path(path_))
+            if m:
+                msg = u'\n' + indent(msg)
+
+            if inf is not None:
+                if m:
+                    msg = u' ' + inf + msg
+                else:
+                    msg = msg + u' ' + inf
+            ret += st + msg + u'\n'
+    elif isinstance(conf, str):
+        if is_secret(conf):
+            conf = u'!secret {}'.format(is_secret(conf))
+        if not conf:
+            conf += u"''"
+
+        if len(conf) > 80:
+            conf = u'|-\n' + indent(conf)
+        error = config.get_error_for_path(path)
+        col = 'bold_red' if error else 'white'
+        ret += color(col, text_type(conf))
+    elif isinstance(conf, core.Lambda):
+        if is_secret(conf):
+            conf = u'!secret {}'.format(is_secret(conf))
+
+        conf = u'!lambda |-\n' + indent(text_type(conf.value))
+        error = config.get_error_for_path(path)
+        col = 'bold_red' if error else 'white'
+        ret += color(col, conf)
+    elif conf is None:
+        pass
+    else:
+        error = config.get_error_for_path(path)
+        col = 'bold_red' if error else 'white'
+        ret += color(col, text_type(conf))
+        multiline = u'\n' in ret
+
+    return ret, multiline
+
+
+def strip_default_ids(config):
+    if isinstance(config, list):
+        to_remove = []
+        for i, x in enumerate(config):
+            x = config[i] = strip_default_ids(x)
+            if isinstance(x, core.ID) and not x.is_manual:
+                to_remove.append(x)
+        for x in to_remove:
+            config.remove(x)
+    elif isinstance(config, dict):
+        to_remove = []
+        for k, v in config.items():
+            v = config[k] = strip_default_ids(v)
+            if isinstance(v, core.ID) and not v.is_manual:
+                to_remove.append(k)
+        for k in to_remove:
+            config.pop(k)
+    return config
+
+
+def read_config(verbose):
+    _LOGGER.info("Reading configuration...")
+    try:
+        res = load_config()
+    except EsphomeError as err:
+        _LOGGER.error(u"Error while reading config: %s", err)
+        return None
+    if res.errors:
+        if not verbose:
+            res = strip_default_ids(res)
+
+        safe_print(color('bold_red', u"Failed config"))
+        safe_print('')
+        for path, domain in res.domains:
+            if not res.is_in_error_path(path):
+                continue
+
+            safe_print(color('bold_red', u'{}:'.format(domain)) + u' ' +
+                       (line_info(res.nested_item(path)) or u''))
+            safe_print(indent(dump_dict(res, path)[0]))
+        return None
+    return OrderedDict(res)

esphome/config_validation.py

@@ -0,0 +1,782 @@
+# coding=utf-8
+"""Helpers for config validation using voluptuous."""
+from __future__ import print_function
+
+import logging
+import os
+import re
+import uuid as uuid_
+
+import voluptuous as vol
+
+from esphome import core
+from esphome.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_ID, \
+    CONF_INTERNAL, CONF_NAME, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PLATFORM, \
+    CONF_RETAIN, CONF_SETUP_PRIORITY, CONF_STATE_TOPIC, CONF_TOPIC, ESP_PLATFORM_ESP32, \
+    ESP_PLATFORM_ESP8266
+from esphome.core import CORE, HexInt, IPAddress, Lambda, TimePeriod, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds, TimePeriodMinutes
+from esphome.py_compat import integer_types, string_types, text_type
+from esphome.voluptuous_schema import _Schema
+
+_LOGGER = logging.getLogger(__name__)
+
+# pylint: disable=invalid-name
+
+Schema = _Schema
+port = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
+float_ = vol.Coerce(float)
+positive_float = vol.All(float_, vol.Range(min=0))
+zero_to_one_float = vol.All(float_, vol.Range(min=0, max=1))
+negative_one_to_one_float = vol.All(float_, vol.Range(min=-1, 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))
+
+ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyz0123456789_'
+
+RESERVED_IDS = [
+    # C++ keywords http://en.cppreference.com/w/cpp/keyword
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'bool', 'break',
+    'case', 'catch', 'char', 'char16_t', 'char32_t', 'class', 'compl', 'concept', 'const',
+    'constexpr', 'const_cast', 'continue', 'decltype', 'default', 'delete', 'do', 'double',
+    'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'export', 'extern', 'false', 'float',
+    'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',
+    'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'private', 'protected',
+    'public', 'register', 'reinterpret_cast', 'requires', 'return', 'short', 'signed', 'sizeof',
+    'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',
+    'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename', 'union', 'unsigned',
+    'using', 'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq',
+
+    'App', 'pinMode', 'delay', 'delayMicroseconds', 'digitalRead', 'digitalWrite', 'INPUT',
+    'OUTPUT',
+    'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'int8_t', 'int16_t', 'int32_t', 'int64_t',
+]
+
+
+def alphanumeric(value):
+    if value is None:
+        raise vol.Invalid("string value is None")
+    value = text_type(value)
+    if not value.isalnum():
+        raise vol.Invalid("string value is not alphanumeric")
+    return value
+
+
+def valid_name(value):
+    value = string_strict(value)
+    for c in value:
+        if c not in ALLOWED_NAME_CHARS:
+            raise vol.Invalid(u"'{}' is an invalid character for names. Valid characters are: {}"
+                              u" (lowercase, no spaces)".format(c, ALLOWED_NAME_CHARS))
+    return value
+
+
+def string(value):
+    if isinstance(value, (dict, list)):
+        raise vol.Invalid("string value cannot be dictionary or list.")
+    if value is not None:
+        return text_type(value)
+    raise vol.Invalid("string value is None")
+
+
+def string_strict(value):
+    """Strictly only allow strings."""
+    if isinstance(value, string_types):
+        return value
+    raise vol.Invalid("Must be string, got {}. did you forget putting quotes "
+                      "around the value?".format(type(value)))
+
+
+def icon(value):
+    """Validate icon."""
+    value = string_strict(value)
+    if value.startswith('mdi:'):
+        return value
+    raise vol.Invalid('Icons should start with prefix "mdi:"')
+
+
+def boolean(value):
+    """Validate and coerce a boolean value."""
+    if isinstance(value, str):
+        value = value.lower()
+        if value in ('1', 'true', 'yes', 'on', 'enable'):
+            return True
+        if value in ('0', 'false', 'no', 'off', 'disable'):
+            return False
+        raise vol.Invalid('invalid boolean value {}'.format(value))
+    return bool(value)
+
+
+def ensure_list(*validators):
+    """Wrap value in list if it is not one."""
+    user = vol.All(*validators)
+
+    def validator(value):
+        if value is None or (isinstance(value, dict) and not value):
+            return []
+        if not isinstance(value, list):
+            return [user(value)]
+        ret = []
+        for i, val in enumerate(value):
+            try:
+                ret.append(user(val))
+            except vol.Invalid as err:
+                err.prepend([i])
+                raise err
+        return ret
+
+    return validator
+
+
+def ensure_list_not_empty(value):
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def ensure_dict(value):
+    if value is None:
+        return {}
+    if not isinstance(value, dict):
+        raise vol.Invalid("Expected a dictionary")
+    return value
+
+
+def hex_int_(value):
+    if isinstance(value, integer_types):
+        return HexInt(value)
+    value = string_strict(value).lower()
+    if value.startswith('0x'):
+        return HexInt(int(value, 16))
+    return HexInt(int(value))
+
+
+def int_(value):
+    if isinstance(value, integer_types):
+        return value
+    value = string_strict(value).lower()
+    if value.startswith('0x'):
+        return int(value, 16)
+    return int(value)
+
+
+hex_int = vol.Coerce(hex_int_)
+
+
+def validate_id_name(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, the underscore"
+                              u"character and numbers. The character '{}' cannot be used"
+                              u"".format(char))
+    if value in RESERVED_IDS:
+        raise vol.Invalid(u"ID {} is reserved internally and cannot be used".format(value))
+    return value
+
+
+def use_variable_id(type):
+    def validator(value):
+        if value is None:
+            return core.ID(None, is_declaration=False, type=type)
+
+        return core.ID(validate_id_name(value), is_declaration=False, type=type)
+
+    return validator
+
+
+def declare_variable_id(type):
+    def validator(value):
+        if value is None:
+            return core.ID(None, is_declaration=True, type=type)
+
+        return core.ID(validate_id_name(value), is_declaration=True, type=type)
+
+    return validator
+
+
+def templatable(other_validators):
+    def validator(value):
+        if isinstance(value, Lambda):
+            return value
+        if isinstance(other_validators, dict):
+            return Schema(other_validators)(value)
+        return other_validators(value)
+
+    return validator
+
+
+def only_on(platforms):
+    if not isinstance(platforms, list):
+        platforms = [platforms]
+
+    def validator_(obj):
+        if CORE.esp_platform not in platforms:
+            raise vol.Invalid(u"This feature is only available on {}".format(platforms))
+        return obj
+
+    return validator_
+
+
+only_on_esp32 = only_on(ESP_PLATFORM_ESP32)
+only_on_esp8266 = only_on(ESP_PLATFORM_ESP8266)
+
+
+# Adapted from:
+# https://github.com/alecthomas/voluptuous/issues/115#issuecomment-144464666
+def has_at_least_one_key(*keys):
+    """Validate that at least one key exists."""
+
+    def validate(obj):
+        """Test keys exist in dict."""
+        if not isinstance(obj, dict):
+            raise vol.Invalid('expected dictionary')
+
+        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
+
+
+def has_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
+
+
+def has_at_most_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)))
+        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, Schema({
+        'days': float_,
+        'hours': float_,
+        'minutes': float_,
+        'seconds': float_,
+        'milliseconds': float_,
+        'microseconds': float_,
+    }),
+    has_at_least_one_key('days', 'hours', 'minutes',
+                         'seconds', 'milliseconds', 'microseconds'),
+    lambda value: TimePeriod(**value))
+
+
+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')
+    if not isinstance(value, str):
+        raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+    try:
+        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_str_unit(value):
+    """Validate and transform time period with time unit and integer value."""
+    if isinstance(value, int):
+        raise vol.Invalid("Don't know what '{0}' means as it has no time *unit*! Did you mean "
+                          "'{0}s'?".format(value))
+    if not isinstance(value, string_types):
+        raise vol.Invalid("Expected string for time period with unit.")
+
+    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:
+        raise vol.Invalid(u"Expected time period with unit, "
+                          u"got {}".format(value))
+    kwarg = unit_to_kwarg[one_of(*unit_to_kwarg)(match.group(2))]
+
+    return TimePeriod(**{kwarg: float(match.group(1))})
+
+
+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())
+
+
+def time_period_in_minutes_(value):
+    if value.microseconds is not None and value.microseconds != 0:
+        raise vol.Invalid("Maximum precision is minutes")
+    if value.milliseconds is not None and value.milliseconds != 0:
+        raise vol.Invalid("Maximum precision is minutes")
+    if value.seconds is not None and value.seconds != 0:
+        raise vol.Invalid("Maximum precision is minutes")
+    return TimePeriodMinutes(**value.as_dict())
+
+
+def update_interval(value):
+    if value == 'never':
+        return 4294967295  # uint32_t max
+    return positive_time_period_milliseconds(value)
+
+
+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_minutes = vol.All(positive_time_period, time_period_in_minutes_)
+time_period_microseconds = vol.All(time_period, time_period_in_microseconds_)
+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))
+
+
+def mac_address(value):
+    value = 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 core.MACAddress(*parts_int)
+
+
+def uuid(value):
+    return vol.Coerce(uuid_.UUID)(value)
+
+
+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 float_with_unit(quantity, regex_suffix):
+    pattern = re.compile(r"^([-+]?[0-9]*\.?[0-9]*)\s*(\w*?)" + regex_suffix + "$")
+
+    def validator(value):
+        match = pattern.match(string(value))
+
+        if match is None:
+            raise vol.Invalid(u"Expected {} with unit, got {}".format(quantity, value))
+
+        mantissa = float(match.group(1))
+        if match.group(2) not in METRIC_SUFFIXES:
+            raise vol.Invalid(u"Invalid {} suffix {}".format(quantity, match.group(2)))
+
+        multiplier = METRIC_SUFFIXES[match.group(2)]
+        return mantissa * multiplier
+
+    return validator
+
+
+frequency = float_with_unit("frequency", r"(Hz|HZ|hz)?")
+resistance = float_with_unit("resistance", r"(Ω|Ω|ohm|Ohm|OHM)?")
+current = float_with_unit("current", r"(a|A|amp|Amp|amps|Amps|ampere|Ampere)?")
+voltage = float_with_unit("voltage", r"(v|V|volt|Volts)?")
+distance = float_with_unit("distance", r"(m)")
+framerate = float_with_unit("framerate", r"(FPS|fps|Fps|FpS|Hz)")
+
+
+def validate_bytes(value):
+    value = string(value)
+    match = re.match(r"^([0-9]+)\s*(\w*?)(?:byte|B|b)?s?$", value)
+
+    if match is None:
+        raise vol.Invalid(u"Expected number of bytes with unit, got {}".format(value))
+
+    mantissa = int(match.group(1))
+    if match.group(2) not in METRIC_SUFFIXES:
+        raise vol.Invalid(u"Invalid metric suffix {}".format(match.group(2)))
+    multiplier = METRIC_SUFFIXES[match.group(2)]
+    if multiplier < 1:
+        raise vol.Invalid(u"Only suffixes with positive exponents are supported. "
+                          u"Got {}".format(match.group(2)))
+    return int(mantissa * multiplier)
+
+
+def hostname(value):
+    value = string(value)
+    if len(value) > 63:
+        raise vol.Invalid("Hostnames can only be 63 characters long")
+    for c in value:
+        if not (c.isalnum() or c in '_-'):
+            raise vol.Invalid("Hostname can only have alphanumeric characters and _ or -")
+    return value
+
+
+def domain(value):
+    value = string(value)
+    if re.match(vol.DOMAIN_REGEX, value) is not None:
+        return value
+    try:
+        return str(ipv4(value))
+    except vol.Invalid:
+        raise vol.Invalid("Invalid domain: {}".format(value))
+
+
+def domain_name(value):
+    value = string_strict(value)
+    if not value:
+        return value
+    if not value.startswith('.'):
+        raise vol.Invalid("Domain name must start with .")
+    if value.startswith('..'):
+        raise vol.Invalid("Domain name must start with single .")
+    for c in value:
+        if not (c.isalnum() or c in '._-'):
+            raise vol.Invalid("Domain name can only have alphanumeric characters and _ or -")
+    return value
+
+
+def ssid(value):
+    value = string_strict(value)
+    if not value:
+        raise vol.Invalid("SSID can't be empty.")
+    if len(value) > 32:
+        raise vol.Invalid("SSID can't be longer than 32 characters")
+    return value
+
+
+def ipv4(value):
+    if isinstance(value, list):
+        parts = value
+    elif isinstance(value, string_types):
+        parts = value.split('.')
+    elif isinstance(value, IPAddress):
+        return value
+    else:
+        raise vol.Invalid("IPv4 address must consist of either string or "
+                          "integer list")
+    if len(parts) != 4:
+        raise vol.Invalid("IPv4 address must consist of four point-separated "
+                          "integers")
+    parts_ = list(map(int, parts))
+    if not all(0 <= x < 256 for x in parts_):
+        raise vol.Invalid("IPv4 address parts must be in range from 0 to 255")
+    return IPAddress(*parts_)
+
+
+def _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
+
+
+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)
+
+
+def requires_component(comp):
+    def validator(value):
+        if comp not in CORE.raw_config:
+            raise vol.Invalid("This option requires component {}".format(comp))
+        return value
+
+    return validator
+
+
+uint8_t = vol.All(int_, vol.Range(min=0, max=255))
+uint16_t = vol.All(int_, vol.Range(min=0, max=65535))
+uint32_t = vol.All(int_, vol.Range(min=0, max=4294967295))
+hex_uint8_t = vol.All(hex_int, vol.Range(min=0, max=255))
+hex_uint16_t = vol.All(hex_int, vol.Range(min=0, max=65535))
+hex_uint32_t = vol.All(hex_int, vol.Range(min=0, max=4294967295))
+i2c_address = hex_uint8_t
+
+
+def percentage(value):
+    value = possibly_negative_percentage(value)
+    return zero_to_one_float(value)
+
+
+def possibly_negative_percentage(value):
+    has_percent_sign = isinstance(value, string_types) and value.endswith('%')
+    if has_percent_sign:
+        value = float(value[:-1].rstrip()) / 100.0
+    if value > 1:
+        msg = "Percentage must not be higher than 100%."
+        if not has_percent_sign:
+            msg += " Please put a percent sign after the number!"
+        raise vol.Invalid(msg)
+    if value < -1:
+        msg = "Percentage must not be smaller than -100%."
+        if not has_percent_sign:
+            msg += " Please put a percent sign after the number!"
+        raise vol.Invalid(msg)
+    return negative_one_to_one_float(value)
+
+
+def percentage_int(value):
+    if isinstance(value, string_types) and value.endswith('%'):
+        value = int(value[:-1].rstrip())
+    return value
+
+
+def invalid(message):
+    def validator(value):
+        raise vol.Invalid(message)
+
+    return validator
+
+
+def valid(value):
+    return value
+
+
+def one_of(*values, **kwargs):
+    options = u', '.join(u"'{}'".format(x) for x in values)
+    lower = kwargs.get('lower', False)
+    upper = kwargs.get('upper', False)
+    string_ = kwargs.get('string', False) or lower or upper
+    to_int = kwargs.get('int', False)
+    space = kwargs.get('space', ' ')
+
+    def validator(value):
+        if string_:
+            value = string(value)
+            value = value.replace(' ', space)
+        if to_int:
+            value = int_(value)
+        if lower:
+            value = vol.Lower(value)
+        if upper:
+            value = vol.Upper(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))
+
+
+def dimensions(value):
+    if isinstance(value, list):
+        if len(value) != 2:
+            raise vol.Invalid(u"Dimensions must have a length of two, not {}".format(len(value)))
+        try:
+            width, height = int(value[0]), int(value[1])
+        except ValueError:
+            raise vol.Invalid(u"Width and height dimensions must be integers")
+        if width <= 0 or height <= 0:
+            raise vol.Invalid(u"Width and height must at least be 1")
+        return [width, height]
+    value = string(value)
+    match = re.match(r"\s*([0-9]+)\s*[xX]\s*([0-9]+)\s*", value)
+    if not match:
+        raise vol.Invalid(u"Invalid value '{}' for dimensions. Only WIDTHxHEIGHT is allowed.")
+    return dimensions([match.group(1), match.group(2)])
+
+
+def directory(value):
+    value = string(value)
+    path = CORE.relative_path(value)
+    if not os.path.exists(path):
+        raise vol.Invalid(u"Could not find directory '{}'. Please make sure it exists.".format(
+            path))
+    if not os.path.isdir(path):
+        raise vol.Invalid(u"Path '{}' is not a directory.".format(path))
+    return value
+
+
+def file_(value):
+    value = string(value)
+    path = CORE.relative_path(value)
+    if not os.path.exists(path):
+        raise vol.Invalid(u"Could not find file '{}'. Please make sure it exists.".format(
+            path))
+    if not os.path.isfile(path):
+        raise vol.Invalid(u"Path '{}' is not a file.".format(path))
+    return value
+
+
+ENTITY_ID_CHARACTERS = 'abcdefghijklmnopqrstuvwxyz0123456789_'
+
+
+def entity_id(value):
+    value = string_strict(value).lower()
+    if value.count('.') != 1:
+        raise vol.Invalid("Entity ID must have exactly one dot in it")
+    for x in value.split('.'):
+        for c in x:
+            if c not in ENTITY_ID_CHARACTERS:
+                raise vol.Invalid("Invalid character for entity ID: {}".format(c))
+    return value
+
+
+class GenerateID(vol.Optional):
+    def __init__(self, key=CONF_ID):
+        super(GenerateID, self).__init__(key, default=lambda: None)
+
+
+def nameable(*schemas):
+    def validator(config):
+        config = vol.All(*schemas)(config)
+        if CONF_NAME not in config and CONF_ID not in config:
+            raise vol.Invalid("At least one of 'id:' or 'name:' is required!")
+        if CONF_NAME not in config:
+            id = config[CONF_ID]
+            if not id.is_manual:
+                raise vol.Invalid("At least one of 'id:' or 'name:' is required!")
+            config[CONF_NAME] = id.id
+            config[CONF_INTERNAL] = True
+            return config
+        return config
+
+    return validator
+
+
+PLATFORM_SCHEMA = Schema({
+    vol.Required(CONF_PLATFORM): valid,
+})
+
+MQTT_COMPONENT_AVAILABILITY_SCHEMA = Schema({
+    vol.Required(CONF_TOPIC): subscribe_topic,
+    vol.Optional(CONF_PAYLOAD_AVAILABLE, default='online'): mqtt_payload,
+    vol.Optional(CONF_PAYLOAD_NOT_AVAILABLE, default='offline'): mqtt_payload,
+})
+
+MQTT_COMPONENT_SCHEMA = Schema({
+    vol.Optional(CONF_NAME): string,
+    vol.Optional(CONF_RETAIN): vol.All(requires_component('mqtt'), boolean),
+    vol.Optional(CONF_DISCOVERY): vol.All(requires_component('mqtt'), boolean),
+    vol.Optional(CONF_STATE_TOPIC): vol.All(requires_component('mqtt'), publish_topic),
+    vol.Optional(CONF_AVAILABILITY): vol.All(requires_component('mqtt'),
+                                             vol.Any(None, MQTT_COMPONENT_AVAILABILITY_SCHEMA)),
+    vol.Optional(CONF_INTERNAL): boolean,
+})
+
+MQTT_COMMAND_COMPONENT_SCHEMA = MQTT_COMPONENT_SCHEMA.extend({
+    vol.Optional(CONF_COMMAND_TOPIC): vol.All(requires_component('mqtt'), subscribe_topic),
+})
+
+COMPONENT_SCHEMA = Schema({
+    vol.Optional(CONF_SETUP_PRIORITY): float_
+})

esphome/const.py

@@ -0,0 +1,435 @@
+"""Constants used by esphome."""
+
+MAJOR_VERSION = 1
+MINOR_VERSION = 12
+PATCH_VERSION = '0'
+__short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
+__version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
+ESPHOME_CORE_VERSION = '1.12.0'
+
+ESP_PLATFORM_ESP32 = 'ESP32'
+ESP_PLATFORM_ESP8266 = 'ESP8266'
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266]
+
+APB_CLOCK_FREQ = 80000000
+
+CONF_ESPHOME = 'esphome'
+CONF_NAME = 'name'
+CONF_PLATFORM = 'platform'
+CONF_BOARD = 'board'
+CONF_ESPHOME_CORE_VERSION = 'esphome_core_version'
+CONF_USE_CUSTOM_CODE = 'use_custom_code'
+CONF_ARDUINO_VERSION = 'arduino_version'
+CONF_LOCAL = 'local'
+CONF_REPOSITORY = 'repository'
+CONF_COMMIT = 'commit'
+CONF_SERVICES = 'services'
+CONF_TAG = 'tag'
+CONF_BRANCH = 'branch'
+CONF_LOGGER = 'logger'
+CONF_WIFI = 'wifi'
+CONF_SSID = 'ssid'
+CONF_IP_ADDRESS = 'ip_address'
+CONF_BSSID = 'bssid'
+CONF_PASSWORD = 'password'
+CONF_MANUAL_IP = 'manual_ip'
+CONF_STATIC_IP = 'static_ip'
+CONF_GATEWAY = 'gateway'
+CONF_SUBNET = 'subnet'
+CONF_OTA = 'ota'
+CONF_MQTT = 'mqtt'
+CONF_BROKER = 'broker'
+CONF_USERNAME = 'username'
+CONF_MIN_LEVEL = 'min_level'
+CONF_IDLE_LEVEL = 'idle_level'
+CONF_MAX_LEVEL = 'max_level'
+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'
+CONF_I2C = 'i2c'
+CONF_SDA = 'sda'
+CONF_SCL = 'scl'
+CONF_FREQUENCY = 'frequency'
+CONF_PCA9685 = 'pca9685'
+CONF_PCA9685_ID = 'pca9685_id'
+CONF_OUTPUT = 'output'
+CONF_CHANNEL = 'channel'
+CONF_CHANNELS = 'channels'
+CONF_LIGHT = 'light'
+CONF_RED = 'red'
+CONF_GREEN = 'green'
+CONF_BLUE = 'blue'
+CONF_SENSOR = 'sensor'
+CONF_TEMPERATURE = 'temperature'
+CONF_HUMIDITY = 'humidity'
+CONF_MODEL = 'model'
+CONF_BINARY_SENSOR = 'binary_sensor'
+CONF_DEVICE_CLASS = 'device_class'
+CONF_GPIO = 'gpio'
+CONF_DHT = 'dht'
+CONF_SAFE_MODE = 'safe_mode'
+CONF_MODE = 'mode'
+CONF_GAMMA_CORRECT = 'gamma_correct'
+CONF_RETAIN = 'retain'
+CONF_DISCOVERY = 'discovery'
+CONF_DISCOVERY_PREFIX = 'discovery_prefix'
+CONF_STATE_TOPIC = 'state_topic'
+CONF_COMMAND_TOPIC = 'command_topic'
+CONF_AVAILABILITY = 'availability'
+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_WHILE = 'while'
+CONF_WAIT_UNTIL = 'wait_until'
+CONF_THEN = 'then'
+CONF_BINARY = 'binary'
+CONF_WHITE = 'white'
+CONF_RGBW = 'rgbw'
+CONF_MAX_POWER = 'max_power'
+CONF_BIT_DEPTH = 'bit_depth'
+CONF_BAUD_RATE = 'baud_rate'
+CONF_LOG_TOPIC = 'log_topic'
+CONF_TX_BUFFER_SIZE = 'tx_buffer_size'
+CONF_LEVEL = 'level'
+CONF_LOGS = 'logs'
+CONF_PORT = 'port'
+CONF_WILL_MESSAGE = 'will_message'
+CONF_BIRTH_MESSAGE = 'birth_message'
+CONF_SHUTDOWN_MESSAGE = 'shutdown_message'
+CONF_PAYLOAD = 'payload'
+CONF_QOS = 'qos'
+CONF_DISCOVERY_RETAIN = 'discovery_retain'
+CONF_TOPIC_PREFIX = 'topic_prefix'
+CONF_PHASE_BALANCER = 'phase_balancer'
+CONF_ADDRESS = 'address'
+CONF_ENABLE_TIME = 'enable_time'
+CONF_KEEP_ON_TIME = 'keep_on_time'
+CONF_DNS1 = 'dns1'
+CONF_DNS2 = 'dns2'
+CONF_UNIT_OF_MEASUREMENT = 'unit_of_measurement'
+CONF_ICON = 'icon'
+CONF_ACCURACY_DECIMALS = 'accuracy_decimals'
+CONF_EXPIRE_AFTER = 'expire_after'
+CONF_FILTERS = 'filters'
+CONF_OFFSET = 'offset'
+CONF_MULTIPLY = 'multiply'
+CONF_FILTER_OUT = 'filter_out'
+CONF_SLIDING_WINDOW_MOVING_AVERAGE = 'sliding_window_moving_average'
+CONF_EXPONENTIAL_MOVING_AVERAGE = 'exponential_moving_average'
+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_CALIBRATE_LINEAR = 'calibrate_linear'
+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'
+CONF_RISING_EDGE = 'rising_edge'
+CONF_FALLING_EDGE = 'falling_edge'
+CONF_INTERNAL_FILTER = 'internal_filter'
+CONF_DALLAS_ID = 'dallas_id'
+CONF_INDEX = 'index'
+CONF_RESOLUTION = 'resolution'
+CONF_ATTENUATION = 'attenuation'
+CONF_PRESSURE = 'pressure'
+CONF_TRIGGER_PIN = 'trigger_pin'
+CONF_ECHO_PIN = 'echo_pin'
+CONF_TIMEOUT = 'timeout'
+CONF_CARRIER_DUTY_PERCENT = 'carrier_duty_percent'
+CONF_NEC = 'nec'
+CONF_COMMAND = 'command'
+CONF_DATA = 'data'
+CONF_NBITS = 'nbits'
+CONF_JVC = 'jvc'
+CONF_RC5 = 'rc5'
+CONF_LG = 'lg'
+CONF_SAMSUNG = 'samsung'
+CONF_SONY = 'sony'
+CONF_PANASONIC = 'panasonic'
+CONF_REPEAT = 'repeat'
+CONF_TIMES = 'times'
+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'
+CONF_MEDIUM = 'medium'
+CONF_HIGH = 'high'
+CONF_NUM_ATTEMPTS = 'num_attempts'
+CONF_CLIENT_ID = 'client_id'
+CONF_RAW = 'raw'
+CONF_CARRIER_FREQUENCY = 'carrier_frequency'
+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_MCP23017 = 'mcp23017'
+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_SETUP_PRIORITY = 'setup_priority'
+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_STATE = 'on_state'
+CONF_ON_CLICK = 'on_click'
+CONF_ON_DOUBLE_CLICK = 'on_double_click'
+CONF_ON_MULTI_CLICK = 'on_multi_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_CS_PIN = 'cs_pin'
+CONF_CLK_PIN = 'clk_pin'
+CONF_MISO_PIN = 'miso_pin'
+CONF_MOSI_PIN = 'mosi_pin'
+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'
+CONF_ASSUMED_STATE = 'assumed_state'
+CONF_ON_BOOT = 'on_boot'
+CONF_ON_SHUTDOWN = 'on_shutdown'
+CONF_PRIORITY = 'priority'
+CONF_DUMP = 'dump'
+CONF_BUFFER_SIZE = 'buffer_size'
+CONF_TOLERANCE = 'tolerance'
+CONF_FILTER = 'filter'
+CONF_IDLE = 'idle'
+CONF_NETWORKS = 'networks'
+CONF_INTERNAL = 'internal'
+CONF_BUILD_PATH = 'build_path'
+CONF_PLATFORMIO_OPTIONS = 'platformio_options'
+CONF_REBOOT_TIMEOUT = 'reboot_timeout'
+CONF_INVERT = 'invert'
+CONF_DELAYED_ON = 'delayed_on'
+CONF_DELAYED_OFF = 'delayed_off'
+CONF_UUID = 'uuid'
+CONF_TYPE = 'type'
+CONF_SPI_ID = 'spi_id'
+CONF_HARDWARE_UART = 'hardware_uart'
+CONF_UART_ID = 'uart_id'
+CONF_UID = 'uid'
+CONF_TX_PIN = 'tx_pin'
+CONF_RX_PIN = 'rx_pin'
+CONF_CO2 = 'co2'
+CONF_SHUNT_RESISTANCE = 'shunt_resistance'
+CONF_MAX_CURRENT = 'max_current'
+CONF_MAX_VOLTAGE = 'max_voltage'
+CONF_CURRENT = 'current'
+CONF_POWER = 'power'
+CONF_BUS_VOLTAGE = 'bus_voltage'
+CONF_SHUNT_VOLTAGE = 'shunt_voltage'
+CONF_CONDITION = 'condition'
+CONF_ELSE = 'else'
+CONF_EFFECTS = 'effects'
+CONF_RANDOM = 'random'
+CONF_EFFECT_ID = 'effect_id'
+CONF_COLORS = 'colors'
+CONF_STATE = 'state'
+CONF_DURATION = 'duration'
+CONF_WIDTH = 'width'
+CONF_ILLUMINANCE = 'illuminance'
+CONF_COLOR_TEMPERATURE = 'color_temperature'
+CONF_BATTERY_LEVEL = 'battery_level'
+CONF_MOISTURE = 'moisture'
+CONF_CONDUCTIVITY = 'conductivity'
+CONF_RC_SWITCH_RAW = 'rc_switch_raw'
+CONF_RC_SWITCH_TYPE_A = 'rc_switch_type_a'
+CONF_RC_SWITCH_TYPE_B = 'rc_switch_type_b'
+CONF_RC_SWITCH_TYPE_C = 'rc_switch_type_c'
+CONF_RC_SWITCH_TYPE_D = 'rc_switch_type_d'
+CONF_CODE = 'code'
+CONF_PROTOCOL = 'protocol'
+CONF_PULSE_LENGTH = 'pulse_length'
+CONF_SYNC = 'sync'
+CONF_ZERO = 'zero'
+CONF_ONE = 'one'
+CONF_GROUP = 'group'
+CONF_DEVICE = 'device'
+CONF_FAMILY = 'family'
+CONF_FILE = 'file'
+CONF_GLYPHS = 'glyphs'
+CONF_SIZE = 'size'
+CONF_RESIZE = 'resize'
+CONF_ROTATION = 'rotation'
+CONF_DC_PIN = 'dc_pin'
+CONF_RESET_PIN = 'reset_pin'
+CONF_BUSY_PIN = 'busy_pin'
+CONF_ESP8266_RESTORE_FROM_FLASH = 'esp8266_restore_from_flash'
+CONF_FULL_UPDATE_EVERY = 'full_update_every'
+CONF_DATA_PINS = 'data_pins'
+CONF_ENABLE_PIN = 'enable_pin'
+CONF_RS_PIN = 'rs_pin'
+CONF_RW_PIN = 'rw_pin'
+CONF_DIMENSIONS = 'dimensions'
+CONF_NUM_CHIPS = 'num_chips'
+CONF_INTENSITY = 'intensity'
+CONF_EXTERNAL_VCC = 'external_vcc'
+CONF_TIMEZONE = 'timezone'
+CONF_SERVERS = 'servers'
+CONF_HEATER = 'heater'
+CONF_VOLTAGE = 'voltage'
+CONF_CURRENT_RESISTOR = 'current_resistor'
+CONF_VOLTAGE_DIVIDER = 'voltage_divider'
+CONF_SEL_PIN = 'sel_pin'
+CONF_CF_PIN = 'cf_pin'
+CONF_CF1_PIN = 'cf1_pin'
+CONF_CHANGE_MODE_EVERY = 'change_mode_every'
+CONF_PAGE_ID = 'page_id'
+CONF_COMPONENT_ID = 'component_id'
+CONF_COLD_WHITE = 'cold_white'
+CONF_PAGES = 'pages'
+CONF_WARM_WHITE = 'warm_white'
+CONF_COLD_WHITE_COLOR_TEMPERATURE = 'cold_white_color_temperature'
+CONF_WARM_WHITE_COLOR_TEMPERATURE = 'warm_white_color_temperature'
+CONF_HIDDEN = 'hidden'
+CONF_ON_LOOP = 'on_loop'
+CONF_ON_TIME = 'on_time'
+CONF_SECONDS = 'seconds'
+CONF_MINUTES = 'minutes'
+CONF_HOURS = 'hours'
+CONF_DAYS_OF_MONTH = 'days_of_month'
+CONF_MONTHS = 'months'
+CONF_DAYS_OF_WEEK = 'days_of_week'
+CONF_CRON = 'cron'
+CONF_POWER_SAVE_MODE = 'power_save_mode'
+CONF_POWER_ON_VALUE = 'power_on_value'
+CONF_PM_1_0 = 'pm_1_0'
+CONF_PM_2_5 = 'pm_2_5'
+CONF_PM_10_0 = 'pm_10_0'
+CONF_FORMALDEHYDE = 'formaldehyde'
+CONF_ON_TAG = 'on_tag'
+CONF_ARGS = 'args'
+CONF_FORMAT = 'format'
+CONF_FOR = 'for'
+CONF_COLOR_CORRECT = 'color_correct'
+CONF_ON_JSON_MESSAGE = 'on_json_message'
+CONF_ACCELERATION = 'acceleration'
+CONF_DECELERATION = 'deceleration'
+CONF_MAX_SPEED = 'max_speed'
+CONF_TARGET = 'target'
+CONF_POSITION = 'position'
+CONF_STEP_PIN = 'step_pin'
+CONF_DIR_PIN = 'dir_pin'
+CONF_SLEEP_PIN = 'sleep_pin'
+CONF_SEND_FIRST_AT = 'send_first_at'
+CONF_TIME_ID = 'time_id'
+CONF_RESTORE_STATE = 'restore_state'
+CONF_TIMING = 'timing'
+CONF_INVALID_COOLDOWN = 'invalid_cooldown'
+CONF_MY9231_ID = 'my9231_id'
+CONF_NUM_CHANNELS = 'num_channels'
+CONF_UPDATE_ON_BOOT = 'update_on_boot'
+CONF_INITIAL_VALUE = 'initial_value'
+CONF_RESTORE_VALUE = 'restore_value'
+CONF_PINS = 'pins'
+CONF_SENSORS = 'sensors'
+CONF_BINARY_SENSORS = 'binary_sensors'
+CONF_OUTPUTS = 'outputs'
+CONF_SWITCHES = 'switches'
+CONF_TEXT_SENSORS = 'text_sensors'
+CONF_INCLUDES = 'includes'
+CONF_LIBRARIES = 'libraries'
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_C = 'pin_c'
+CONF_PIN_D = 'pin_d'
+CONF_SLEEP_WHEN_DONE = 'sleep_when_done'
+CONF_STEP_MODE = 'step_mode'
+CONF_COMPONENTS = 'components'
+CONF_DATA_TEMPLATE = 'data_template'
+CONF_VARIABLES = 'variables'
+CONF_SERVICE = 'service'
+CONF_ENTITY_ID = 'entity_id'
+CONF_RESTORE_MODE = 'restore_mode'
+CONF_INTERVAL = 'interval'
+CONF_DIRECTION = 'direction'
+CONF_VARIANT = 'variant'
+CONF_METHOD = 'method'
+CONF_FAST_CONNECT = 'fast_connect'
+CONF_INTERLOCK = 'interlock'
+CONF_ON_TURN_ON = 'on_turn_on'
+CONF_ON_TURN_OFF = 'on_turn_off'
+CONF_USE_ADDRESS = 'use_address'
+CONF_FROM = 'from'
+CONF_TO = 'to'
+CONF_SEGMENTS = 'segments'
+CONF_MIN_POWER = 'min_power'
+CONF_MIN_VALUE = 'min_value'
+CONF_MAX_VALUE = 'max_value'
+CONF_RX_ONLY = 'rx_only'
+
+
+ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyz0123456789_'
+ARDUINO_VERSION_ESP32_DEV = 'https://github.com/platformio/platform-espressif32.git#feature/stage'
+ARDUINO_VERSION_ESP32_1_0_0 = 'espressif32@1.5.0'
+ARDUINO_VERSION_ESP32_1_0_1 = 'espressif32@1.6.0'
+ARDUINO_VERSION_ESP8266_DEV = 'https://github.com/platformio/platform-espressif8266.git#feature' \
+                              '/stage'
+ARDUINO_VERSION_ESP8266_2_5_0 = 'espressif8266@2.0.0'

esphome/core.py

@@ -0,0 +1,461 @@
+import collections
+from collections import OrderedDict
+import inspect
+import logging
+import math
+import os
+import re
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import Any, Dict, List  # noqa
+
+from esphome.const import CONF_ARDUINO_VERSION, CONF_ESPHOME, CONF_ESPHOME_CORE_VERSION, \
+    CONF_LOCAL, CONF_USE_ADDRESS, CONF_WIFI, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, \
+    CONF_REPOSITORY, CONF_BRANCH
+from esphome.helpers import ensure_unique_string, is_hassio
+from esphome.py_compat import IS_PY2, integer_types
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EsphomeError(Exception):
+    """General ESPHome exception occurred."""
+
+
+if IS_PY2:
+    base_int = long
+else:
+    base_int = int
+
+
+class HexInt(base_int):
+    def __str__(self):
+        if 0 <= self <= 255:
+            return "0x{:02X}".format(self)
+        return "0x{:X}".format(self)
+
+
+class IPAddress(object):
+    def __init__(self, *args):
+        if len(args) != 4:
+            raise ValueError(u"IPAddress must consist up 4 items")
+        self.args = args
+
+    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 as_hex(self):
+        from esphome.cpp_generator import RawExpression
+
+        num = ''.join('{:02X}'.format(part) for part in self.parts)
+        return RawExpression('0x{}ULL'.format(num))
+
+
+def is_approximately_integer(value):
+    if isinstance(value, integer_types):
+        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
+
+    def __str__(self):
+        if self.microseconds is not None:
+            return '{} us'.format(self.total_microseconds)
+        if self.milliseconds is not None:
+            return '{} ms'.format(self.total_milliseconds)
+        if self.seconds is not None:
+            return '{} s'.format(self.total_seconds)
+        if self.minutes is not None:
+            return '{} min'.format(self.total_minutes)
+        if self.hours is not None:
+            return '{} h'.format(self.total_hours)
+        if self.days is not None:
+            return '{} d'.format(self.total_days)
+        return '0'
+
+    @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 TimePeriodMinutes(TimePeriod):
+    pass
+
+
+LAMBDA_PROG = re.compile(r'id\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)')
+
+
+class Lambda(object):
+    def __init__(self, value):
+        self._value = value
+        self._parts = None
+        self._requires_ids = None
+
+    @property
+    def parts(self):
+        if self._parts is None:
+            self._parts = re.split(LAMBDA_PROG, self._value)
+        return self._parts
+
+    @property
+    def requires_ids(self):
+        if self._requires_ids is None:
+            self._requires_ids = [ID(self.parts[i]) for i in range(1, len(self.parts), 3)]
+        return self._requires_ids
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+        self._parts = None
+        self._requires_ids = None
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return u'Lambda<{}>'.format(self.value)
+
+
+class ID(object):
+    def __init__(self, id, is_declaration=False, type=None):
+        self.id = id
+        self.is_manual = id is not None
+        self.is_declaration = is_declaration
+        self.type = type
+
+    def resolve(self, registered_ids):
+        from esphome.config_validation import RESERVED_IDS
+
+        if self.id is None:
+            base = str(self.type).replace('::', '_').lower()
+            name = ''.join(c for c in base if c.isalnum() or c == '_')
+            used = set(registered_ids) | set(RESERVED_IDS)
+            self.id = ensure_unique_string(name, used)
+        return self.id
+
+    def __str__(self):
+        if self.id is None:
+            return ''
+        return self.id
+
+    def __repr__(self):
+        return u'ID<{} declaration={}, type={}, manual={}>'.format(
+            self.id, self.is_declaration, self.type, self.is_manual)
+
+    def __eq__(self, other):
+        if not isinstance(other, ID):
+            raise ValueError("other must be ID")
+        return self.id == other.id
+
+    def __hash__(self):
+        return hash(self.id)
+
+
+# pylint: disable=too-many-instance-attributes,too-many-public-methods
+class EsphomeCore(object):
+    def __init__(self):
+        # True if command is run from dashboard
+        self.dashboard = False
+        # The name of the node
+        self.name = None  # type: str
+        # The relative path to the configuration YAML
+        self.config_path = None  # type: str
+        # The relative path to where all build files are stored
+        self.build_path = None  # type: str
+        # The platform (ESP8266, ESP32) of this device
+        self.esp_platform = None  # type: str
+        # The board that's used (for example nodemcuv2)
+        self.board = None  # type: str
+        # The full raw configuration
+        self.raw_config = {}  # type: ConfigType
+        # The validated configuration, this is None until the config has been validated
+        self.config = {}  # type: ConfigType
+        # The pending tasks in the task queue (mostly for C++ generation)
+        self.pending_tasks = collections.deque()
+        # The variable cache, for each ID this holds a MockObj of the variable obj
+        self.variables = {}  # type: Dict[str, MockObj]
+        # The list of expressions for the C++ generation
+        self.expressions = []  # type: List[Expression]
+
+    @property
+    def address(self):  # type: () -> str
+        if 'wifi' in self.config:
+            return self.config[CONF_WIFI][CONF_USE_ADDRESS]
+
+        if 'ethernet' in self.config:
+            return self.config['ethernet'][CONF_USE_ADDRESS]
+
+        return None
+
+    @property
+    def esphome_core_version(self):  # type: () -> Dict[str, str]
+        return self.config[CONF_ESPHOME][CONF_ESPHOME_CORE_VERSION]
+
+    @property
+    def is_dev_esphome_core_version(self):
+        if CONF_REPOSITORY not in self.esphome_core_version:
+            return False
+        return self.esphome_core_version.get(CONF_BRANCH) == 'dev'
+
+    @property
+    def is_local_esphome_core_copy(self):
+        return CONF_LOCAL in self.esphome_core_version
+
+    @property
+    def arduino_version(self):  # type: () -> str
+        return self.config[CONF_ESPHOME][CONF_ARDUINO_VERSION]
+
+    @property
+    def config_dir(self):
+        return os.path.dirname(self.config_path)
+
+    @property
+    def config_filename(self):
+        return os.path.basename(self.config_path)
+
+    def relative_path(self, *path):
+        path_ = os.path.expanduser(os.path.join(*path))
+        return os.path.join(self.config_dir, path_)
+
+    def relative_build_path(self, *path):
+        path_ = os.path.expanduser(os.path.join(*path))
+        return os.path.join(self.build_path, path_)
+
+    def relative_pioenvs_path(self, *path):
+        if is_hassio():
+            return os.path.join('/data', self.name, '.pioenvs', *path)
+        return self.relative_build_path('.pioenvs', *path)
+
+    def relative_piolibdeps_path(self, *path):
+        if is_hassio():
+            return os.path.join('/data', self.name, '.piolibdeps', *path)
+        return self.relative_build_path('.piolibdeps', *path)
+
+    @property
+    def firmware_bin(self):
+        return self.relative_pioenvs_path(self.name, 'firmware.bin')
+
+    @property
+    def is_esp8266(self):
+        if self.esp_platform is None:
+            raise ValueError
+        return self.esp_platform == ESP_PLATFORM_ESP8266
+
+    @property
+    def is_esp32(self):
+        if self.esp_platform is None:
+            raise ValueError
+        return self.esp_platform == ESP_PLATFORM_ESP32
+
+    def add_job(self, func, *args, **kwargs):
+        domain = kwargs.get('domain')
+        if inspect.isgeneratorfunction(func):
+            def func_():
+                yield
+                for _ in func(*args):
+                    yield
+        else:
+            def func_():
+                yield
+                func(*args)
+        gen = func_()
+        self.pending_tasks.append((gen, domain))
+        return gen
+
+    def flush_tasks(self):
+        i = 0
+        while self.pending_tasks:
+            i += 1
+            if i > 1000000:
+                raise EsphomeError("Circular dependency detected!")
+
+            task, domain = self.pending_tasks.popleft()
+            _LOGGER.debug("Executing task for domain=%s", domain)
+            try:
+                next(task)
+                self.pending_tasks.append((task, domain))
+            except StopIteration:
+                _LOGGER.debug(" -> %s finished", domain)
+
+    def add(self, expression, require=True):
+        from esphome.cpp_generator import Expression
+
+        if require and isinstance(expression, Expression):
+            expression.require()
+        self.expressions.append(expression)
+        _LOGGER.debug("Adding: %s", expression)
+        return expression
+
+    def get_variable(self, id):
+        while True:
+            if id in self.variables:
+                yield self.variables[id]
+                return
+            _LOGGER.debug("Waiting for variable %s", id)
+            yield None
+
+    def get_variable_with_full_id(self, id):
+        while True:
+            if id in self.variables:
+                for k, v in self.variables.items():
+                    if k == id:
+                        yield (k, v)
+                        return
+            _LOGGER.debug("Waiting for variable %s", id)
+            yield None, None
+
+    def register_variable(self, id, obj):
+        if id in self.variables:
+            raise EsphomeError("ID {} is already registered".format(id))
+        _LOGGER.debug("Registered variable %s of type %s", id.id, id.type)
+        self.variables[id] = obj
+
+    def has_id(self, id):
+        return id in self.variables
+
+
+CORE = EsphomeCore()
+
+ConfigType = Dict[str, Any]
+CoreType = EsphomeCore

esphome/core_config.py

@@ -0,0 +1,255 @@
+import logging
+import os
+import re
+
+import voluptuous as vol
+
+from esphome import automation, pins
+import esphome.config_validation as cv
+from esphome.const import ARDUINO_VERSION_ESP32_DEV, ARDUINO_VERSION_ESP8266_DEV, \
+    CONF_ARDUINO_VERSION, CONF_BOARD, CONF_BOARD_FLASH_MODE, CONF_BRANCH, CONF_BUILD_PATH, \
+    CONF_COMMIT, CONF_ESPHOME, CONF_ESPHOME_CORE_VERSION, CONF_INCLUDES, CONF_LIBRARIES, \
+    CONF_LOCAL, CONF_NAME, CONF_ON_BOOT, CONF_ON_LOOP, CONF_ON_SHUTDOWN, CONF_PLATFORM, \
+    CONF_PLATFORMIO_OPTIONS, CONF_PRIORITY, CONF_REPOSITORY, CONF_TAG, CONF_TRIGGER_ID, \
+    CONF_USE_CUSTOM_CODE, ESPHOME_CORE_VERSION, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, \
+    CONF_ESP8266_RESTORE_FROM_FLASH
+from esphome.core import CORE, EsphomeError
+from esphome.cpp_generator import Pvariable, RawExpression, add
+from esphome.cpp_types import App, const_char_ptr, esphome_ns
+from esphome.py_compat import text_type
+
+_LOGGER = logging.getLogger(__name__)
+
+LIBRARY_URI_REPO = u'https://github.com/esphome/esphome-core.git'
+GITHUB_ARCHIVE_ZIP = u'https://github.com/esphome/esphome-core/archive/{}.zip'
+
+BUILD_FLASH_MODES = ['qio', 'qout', 'dio', 'dout']
+StartupTrigger = esphome_ns.StartupTrigger
+ShutdownTrigger = esphome_ns.ShutdownTrigger
+LoopTrigger = esphome_ns.LoopTrigger
+
+VERSION_REGEX = re.compile(r'^[0-9]+\.[0-9]+\.[0-9]+(?:[ab]\d+)?$')
+
+
+def validate_board(value):
+    if CORE.is_esp8266:
+        board_pins = pins.ESP8266_BOARD_PINS
+    elif CORE.is_esp32:
+        board_pins = pins.ESP32_BOARD_PINS
+    else:
+        raise NotImplementedError
+
+    if value not in board_pins:
+        raise vol.Invalid(u"Could not find board '{}'. Valid boards are {}".format(
+            value, u', '.join(pins.ESP8266_BOARD_PINS.keys())))
+    return value
+
+
+def validate_simple_esphome_core_version(value):
+    value = cv.string_strict(value)
+    if value.upper() == 'LATEST':
+        if ESPHOME_CORE_VERSION == 'dev':
+            return validate_simple_esphome_core_version('dev')
+        return {
+            CONF_REPOSITORY: LIBRARY_URI_REPO,
+            CONF_TAG: 'v' + ESPHOME_CORE_VERSION,
+        }
+    if value.upper() == 'DEV':
+        return {
+            CONF_REPOSITORY: LIBRARY_URI_REPO,
+            CONF_BRANCH: 'dev'
+        }
+    if VERSION_REGEX.match(value) is not None:
+        return {
+            CONF_REPOSITORY: LIBRARY_URI_REPO,
+            CONF_TAG: 'v' + value,
+        }
+    raise vol.Invalid("Only simple esphome core versions!")
+
+
+def validate_local_esphome_core_version(value):
+    value = cv.directory(value)
+    path = CORE.relative_path(value)
+    library_json = os.path.join(path, 'library.json')
+    if not os.path.exists(library_json):
+        raise vol.Invalid(u"Could not find '{}' file. '{}' does not seem to point to an "
+                          u"esphome-core copy.".format(library_json, value))
+    return value
+
+
+def validate_commit(value):
+    value = cv.string(value)
+    if re.match(r"^[0-9a-f]{7,}$", value) is None:
+        raise vol.Invalid("Commit option only accepts commit hashes in hex format.")
+    return value
+
+
+ESPHOME_CORE_VERSION_SCHEMA = vol.Any(
+    validate_simple_esphome_core_version,
+    cv.Schema({
+        vol.Required(CONF_LOCAL): validate_local_esphome_core_version,
+    }),
+    vol.All(
+        cv.Schema({
+            vol.Optional(CONF_REPOSITORY, default=LIBRARY_URI_REPO): cv.string,
+            vol.Optional(CONF_COMMIT): validate_commit,
+            vol.Optional(CONF_BRANCH): cv.string,
+            vol.Optional(CONF_TAG): cv.string,
+        }),
+        cv.has_at_most_one_key(CONF_COMMIT, CONF_BRANCH, CONF_TAG)
+    ),
+)
+
+
+def validate_platform(value):
+    value = cv.string(value)
+    if value.upper() in ('ESP8266', 'ESPRESSIF8266'):
+        return ESP_PLATFORM_ESP8266
+    if value.upper() in ('ESP32', 'ESPRESSIF32'):
+        return ESP_PLATFORM_ESP32
+    raise vol.Invalid(u"Invalid platform '{}'. Only options are ESP8266 and ESP32. Please note "
+                      u"the old way to use the latest arduino framework version has been split up "
+                      u"into the arduino_version configuration option.".format(value))
+
+
+PLATFORMIO_ESP8266_LUT = {
+    '2.5.0': 'espressif8266@2.0.1',
+    '2.4.2': 'espressif8266@1.8.0',
+    '2.4.1': 'espressif8266@1.7.3',
+    '2.4.0': 'espressif8266@1.6.0',
+    '2.3.0': 'espressif8266@1.5.0',
+    'RECOMMENDED': 'espressif8266@1.8.0',
+    'LATEST': 'espressif8266',
+    'DEV': ARDUINO_VERSION_ESP8266_DEV,
+}
+
+PLATFORMIO_ESP32_LUT = {
+    '1.0.0': 'espressif32@1.4.0',
+    '1.0.1': 'espressif32@1.6.0',
+    'RECOMMENDED': 'espressif32@1.6.0',
+    'LATEST': 'espressif32',
+    'DEV': ARDUINO_VERSION_ESP32_DEV,
+}
+
+
+def validate_arduino_version(value):
+    value = cv.string_strict(value)
+    value_ = value.upper()
+    if CORE.is_esp8266:
+        if VERSION_REGEX.match(value) is not None and value_ not in PLATFORMIO_ESP8266_LUT:
+            raise vol.Invalid("Unfortunately the arduino framework version '{}' is unsupported "
+                              "at this time. You can override this by manually using "
+                              "espressif8266@<platformio version>")
+        if value_ in PLATFORMIO_ESP8266_LUT:
+            return PLATFORMIO_ESP8266_LUT[value_]
+        return value
+    if CORE.is_esp32:
+        if VERSION_REGEX.match(value) is not None and value_ not in PLATFORMIO_ESP32_LUT:
+            raise vol.Invalid("Unfortunately the arduino framework version '{}' is unsupported "
+                              "at this time. You can override this by manually using "
+                              "espressif32@<platformio version>")
+        if value_ in PLATFORMIO_ESP32_LUT:
+            return PLATFORMIO_ESP32_LUT[value_]
+        return value
+    raise NotImplementedError
+
+
+def default_build_path():
+    return CORE.name
+
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_NAME): cv.valid_name,
+    vol.Required(CONF_PLATFORM): cv.one_of('ESP8266', 'ESPRESSIF8266', 'ESP32', 'ESPRESSIF32',
+                                           upper=True),
+    vol.Required(CONF_BOARD): validate_board,
+    vol.Optional(CONF_ESPHOME_CORE_VERSION, default='latest'): ESPHOME_CORE_VERSION_SCHEMA,
+    vol.Optional(CONF_ARDUINO_VERSION, default='recommended'): validate_arduino_version,
+    vol.Optional(CONF_USE_CUSTOM_CODE, default=False): cv.boolean,
+    vol.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string,
+    vol.Optional(CONF_PLATFORMIO_OPTIONS): cv.Schema({
+        cv.string_strict: vol.Any([cv.string], cv.string),
+    }),
+    vol.Optional(CONF_ESP8266_RESTORE_FROM_FLASH): vol.All(cv.only_on_esp8266, cv.boolean),
+
+    vol.Optional(CONF_BOARD_FLASH_MODE, default='dout'): cv.one_of(*BUILD_FLASH_MODES, lower=True),
+    vol.Optional(CONF_ON_BOOT): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StartupTrigger),
+        vol.Optional(CONF_PRIORITY): cv.float_,
+    }),
+    vol.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ShutdownTrigger),
+    }),
+    vol.Optional(CONF_ON_LOOP): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(LoopTrigger),
+    }),
+    vol.Optional(CONF_INCLUDES): cv.ensure_list(cv.file_),
+    vol.Optional(CONF_LIBRARIES): cv.ensure_list(cv.string_strict),
+
+    vol.Optional('esphomelib_version'): cv.invalid("The esphomelib_version has been renamed to "
+                                                   "esphome_core_version in 1.11.0"),
+})
+
+
+def preload_core_config(config):
+    if 'esphomeyaml' in config:
+        _LOGGER.warning("The esphomeyaml section has been renamed to esphome in 1.11.0. "
+                        "Please replace 'esphomeyaml:' in your configuration with 'esphome:'.")
+        config[CONF_ESPHOME] = config.pop('esphomeyaml')
+    if CONF_ESPHOME not in config:
+        raise EsphomeError(u"No esphome section in config")
+    core_conf = config[CONF_ESPHOME]
+    if CONF_PLATFORM not in core_conf:
+        raise EsphomeError("esphome.platform not specified.")
+    if CONF_BOARD not in core_conf:
+        raise EsphomeError("esphome.board not specified.")
+    if CONF_NAME not in core_conf:
+        raise EsphomeError("esphome.name not specified.")
+
+    try:
+        CORE.esp_platform = validate_platform(core_conf[CONF_PLATFORM])
+        CORE.board = validate_board(core_conf[CONF_BOARD])
+        CORE.name = cv.valid_name(core_conf[CONF_NAME])
+        CORE.build_path = CORE.relative_path(
+            cv.string(core_conf.get(CONF_BUILD_PATH, default_build_path())))
+    except vol.Invalid as e:
+        raise EsphomeError(text_type(e))
+
+
+def to_code(config):
+    add(App.set_name(config[CONF_NAME]))
+
+    for conf in config.get(CONF_ON_BOOT, []):
+        rhs = App.register_component(StartupTrigger.new(conf.get(CONF_PRIORITY)))
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_SHUTDOWN, []):
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], ShutdownTrigger.new())
+        automation.build_automations(trigger, [(const_char_ptr, 'x')], conf)
+
+    for conf in config.get(CONF_ON_LOOP, []):
+        rhs = App.register_component(LoopTrigger.new())
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+
+    add(App.set_compilation_datetime(RawExpression('__DATE__ ", " __TIME__')))
+
+
+def lib_deps(config):
+    return set(config.get(CONF_LIBRARIES, []))
+
+
+def includes(config):
+    ret = []
+    for include in config.get(CONF_INCLUDES, []):
+        path = CORE.relative_path(include)
+        res = os.path.relpath(path, CORE.relative_build_path('src'))
+        ret.append(u'#include "{}"'.format(res))
+    return ret
+
+
+def required_build_flags(config):
+    if config.get(CONF_ESP8266_RESTORE_FROM_FLASH, False):
+        return ['-DUSE_ESP8266_PREFERENCES_FLASH']
+    return []

esphome/cpp_generator.py

@@ -0,0 +1,572 @@
+from collections import OrderedDict
+
+from esphome.core import CORE, HexInt, Lambda, TimePeriod, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds, TimePeriodMinutes
+from esphome.helpers import cpp_string_escape, indent_all_but_first_and_last
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import Any, Generator, List, Optional, Tuple, Union  # noqa
+from esphome.core import ID  # noqa
+from esphome.py_compat import text_type, string_types, integer_types
+
+
+class Expression(object):
+    def __init__(self):
+        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
+
+
+SafeExpType = Union[Expression, bool, str, text_type, int, float, TimePeriod]
+
+
+class RawExpression(Expression):
+    def __init__(self, text):  # type: (Union[str, unicode]) -> None
+        super(RawExpression, self).__init__()
+        self.text = text
+
+    def __str__(self):
+        return str(self.text)
+
+
+# pylint: disable=redefined-builtin
+class AssignmentExpression(Expression):
+    def __init__(self, type, modifier, name, rhs, obj):
+        super(AssignmentExpression, self).__init__()
+        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):
+        type_ = self.type
+        return u"{} {}{} = {}".format(type_, self.modifier, self.name, self.rhs)
+
+    def has_side_effects(self):
+        return self.rhs.has_side_effects()
+
+
+class ExpressionList(Expression):
+    def __init__(self, *args):
+        super(ExpressionList, self).__init__()
+        # Remove every None on end
+        args = list(args)
+        while args and args[-1] is None:
+            args.pop()
+        self.args = []
+        for arg in args:
+            exp = safe_exp(arg)
+            self.requires.append(exp)
+            self.args.append(exp)
+
+    def __str__(self):
+        text = u", ".join(text_type(x) for x in self.args)
+        return indent_all_but_first_and_last(text)
+
+
+class TemplateArguments(Expression):
+    def __init__(self, *args):  # type: (*SafeExpType) -> None
+        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):  # type: (Expression, *SafeExpType) -> None
+        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)
+
+
+class StructInitializer(Expression):
+    def __init__(self, base, *args):  # type: (Expression, *Tuple[str, SafeExpType]) -> None
+        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.items():
+            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)
+        for key, value in self.args.items():
+            cpp += u'  .{} = {},\n'.format(key, value)
+        cpp += u'}'
+        return cpp
+
+
+class ArrayInitializer(Expression):
+    def __init__(self, *args, **kwargs):  # type: (*Any, **Any) -> None
+        super(ArrayInitializer, self).__init__()
+        self.multiline = kwargs.get('multiline', False)
+        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'{}'
+        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
+
+
+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(text_type(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), 3):
+            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{}\n}}'.format(self.content)
+        return indent_all_but_first_and_last(cpp)
+
+    @property
+    def content(self):
+        return u''.join(text_type(part) for part in self.parts)
+
+
+class Literal(Expression):
+    def __str__(self):
+        raise NotImplementedError
+
+
+class StringLiteral(Literal):
+    def __init__(self, string):  # type: (Union[str, unicode]) -> None
+        super(StringLiteral, self).__init__()
+        self.string = string
+
+    def __str__(self):
+        return u'{}'.format(cpp_string_escape(self.string))
+
+
+class IntLiteral(Literal):
+    def __init__(self, i):  # type: (Union[int, long]) -> None
+        super(IntLiteral, self).__init__()
+        self.i = i
+
+    def __str__(self):
+        if self.i > 4294967295:
+            return u'{}ULL'.format(self.i)
+        if self.i > 2147483647:
+            return u'{}UL'.format(self.i)
+        if self.i < -2147483648:
+            return u'{}LL'.format(self.i)
+        return text_type(self.i)
+
+
+class BoolLiteral(Literal):
+    def __init__(self, binary):  # type: (bool) -> None
+        super(BoolLiteral, self).__init__()
+        self.binary = binary
+
+    def __str__(self):
+        return u"true" if self.binary else u"false"
+
+
+class HexIntLiteral(Literal):
+    def __init__(self, i):  # type: (int) -> None
+        super(HexIntLiteral, self).__init__()
+        self.i = HexInt(i)
+
+    def __str__(self):
+        return str(self.i)
+
+
+class FloatLiteral(Literal):
+    def __init__(self, value):  # type: (float) -> None
+        super(FloatLiteral, self).__init__()
+        self.float_ = value
+
+    def __str__(self):
+        return u"{:f}f".format(self.float_)
+
+
+# pylint: disable=bad-continuation
+def safe_exp(
+        obj  # type: Union[Expression, bool, str, unicode, int, long, float, TimePeriod, list]
+             ):
+    # type: (...) -> Expression
+    if isinstance(obj, Expression):
+        return obj
+    if isinstance(obj, bool):
+        return BoolLiteral(obj)
+    if isinstance(obj, string_types):
+        return StringLiteral(obj)
+    if isinstance(obj, HexInt):
+        return HexIntLiteral(obj)
+    if isinstance(obj, integer_types):
+        return IntLiteral(obj)
+    if isinstance(obj, float):
+        return FloatLiteral(obj)
+    if isinstance(obj, TimePeriodMicroseconds):
+        return IntLiteral(int(obj.total_microseconds))
+    if isinstance(obj, TimePeriodMilliseconds):
+        return IntLiteral(int(obj.total_milliseconds))
+    if isinstance(obj, TimePeriodSeconds):
+        return IntLiteral(int(obj.total_seconds))
+    if isinstance(obj, TimePeriodMinutes):
+        return IntLiteral(int(obj.total_minutes))
+    if isinstance(obj, (tuple, list)):
+        return ArrayInitializer(*[safe_exp(o) for o in obj])
+    raise ValueError(u"Object is not an expression", obj)
+
+
+class Statement(object):
+    def __init__(self):
+        pass
+
+    def __str__(self):
+        raise NotImplementedError
+
+
+class RawStatement(Statement):
+    def __init__(self, text):
+        super(RawStatement, self).__init__()
+        self.text = text
+
+    def __str__(self):
+        return self.text
+
+
+class ExpressionStatement(Statement):
+    def __init__(self, expression):
+        super(ExpressionStatement, self).__init__()
+        self.expression = safe_exp(expression)
+
+    def __str__(self):
+        return u"{};".format(self.expression)
+
+
+class ProgmemAssignmentExpression(AssignmentExpression):
+    def __init__(self, type, name, rhs, obj):
+        super(ProgmemAssignmentExpression, self).__init__(
+            type, '', name, rhs, obj
+        )
+
+    def __str__(self):
+        type_ = self.type
+        return u"static const {} {}[] PROGMEM = {}".format(type_, self.name, self.rhs)
+
+
+def progmem_array(id, rhs):
+    rhs = safe_exp(rhs)
+    obj = MockObj(id, u'.')
+    assignment = ProgmemAssignmentExpression(id.type, id, rhs, obj)
+    CORE.add(assignment)
+    CORE.register_variable(id, obj)
+    obj.requires.append(assignment)
+    return obj
+
+
+def statement(expression):  # type: (Union[Expression, Statement]) -> Statement
+    if isinstance(expression, Statement):
+        return expression
+    return ExpressionStatement(expression)
+
+
+def variable(id,  # type: ID
+             rhs,  # type: Expression
+             type=None  # type: MockObj
+             ):
+    # type: (...) -> MockObj
+    rhs = safe_exp(rhs)
+    obj = MockObj(id, u'.')
+    id.type = type or id.type
+    assignment = AssignmentExpression(id.type, '', id, rhs, obj)
+    CORE.add(assignment)
+    CORE.register_variable(id, obj)
+    obj.requires.append(assignment)
+    return obj
+
+
+def Pvariable(id,  # type: ID
+              rhs,  # type: Expression
+              has_side_effects=True,  # type: bool
+              type=None  # type: MockObj
+              ):
+    # type: (...) -> MockObj
+    rhs = safe_exp(rhs)
+    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)
+    id.type = type or id.type
+    assignment = AssignmentExpression(id.type, '*', id, rhs, obj)
+    CORE.add(assignment)
+    CORE.register_variable(id, obj)
+    obj.requires.append(assignment)
+    return obj
+
+
+def add(expression,  # type: Union[Expression, Statement]
+        require=True  # type: bool
+        ):
+    # type: (...) -> None
+    CORE.add(expression, require=require)
+
+
+def get_variable(id):  # type: (ID) -> Generator[MockObj]
+    for var in CORE.get_variable(id):
+        yield None
+    yield var
+
+
+def process_lambda(value,  # type: Lambda
+                   parameters,  # type: List[Tuple[Expression, str]]
+                   capture='=',  # type: str
+                   return_type=None  # type: Optional[Expression]
+                   ):
+    # type: (...) -> Generator[LambdaExpression]
+    from esphome.components.globals import GlobalVariableComponent
+
+    if value is None:
+        yield
+        return
+    parts = value.parts[:]
+    for i, id in enumerate(value.requires_ids):
+        for full_id, var in CORE.get_variable_with_full_id(id):
+            yield
+        if full_id is not None and isinstance(full_id.type, MockObjClass) and \
+                full_id.type.inherits_from(GlobalVariableComponent):
+            parts[i * 3 + 1] = var.value()
+            continue
+
+        if parts[i * 3 + 2] == '.':
+            parts[i * 3 + 1] = var._
+        else:
+            parts[i * 3 + 1] = var
+        parts[i * 3 + 2] = ''
+    yield LambdaExpression(parts, parameters, capture, return_type)
+
+
+def templatable(value,  # type: Any
+                args,  # type: List[Tuple[Expression, str]]
+                output_type  # type: Optional[Expression]
+                ):
+    if isinstance(value, Lambda):
+        for lambda_ in process_lambda(value, args, return_type=output_type):
+            yield None
+        yield lambda_
+    else:
+        yield value
+
+
+class MockObj(Expression):
+    def __init__(self, base, op=u'.', has_side_effects=True):
+        self.base = base
+        self.op = op
+        self._has_side_effects = has_side_effects
+        super(MockObj, self).__init__()
+
+    def __getattr__(self, attr):  # type: (str) -> MockObj
+        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') and self.op not in ['::', '']:
+            attr = attr[1:]
+            next_op = u'->'
+        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):  # type: (*Any, **Any) -> MockObj
+        call = CallExpression(self.base, *args)
+        obj = MockObj(call, self.op)
+        obj.requires.append(self)
+        obj.requires.append(call)
+        return obj
+
+    def __str__(self):  # type: () -> unicode
+        return text_type(self.base)
+
+    def require(self):  # type: () -> None
+        self.required = True
+        for require in self.requires:
+            if require.required:
+                continue
+            require.require()
+
+    def template(self, *args):  # type: (Tuple[Union[TemplateArguments, Expression]]) -> MockObj
+        if len(args) != 1 or not isinstance(args[0], TemplateArguments):
+            args = TemplateArguments(*args)
+        else:
+            args = args[0]
+        obj = MockObj(u'{}{}'.format(self.base, args))
+        obj.requires.append(self)
+        obj.requires.append(args)
+        return obj
+
+    def namespace(self, name):  # type: (str) -> MockObj
+        obj = MockObj(u'{}{}{}'.format(self.base, self.op, name), u'::')
+        obj.requires.append(self)
+        return obj
+
+    def class_(self, name, *parents):  # type: (str, *MockObjClass) -> MockObjClass
+        op = '' if self.op == '' else '::'
+        obj = MockObjClass(u'{}{}{}'.format(self.base, op, name), u'.', parents=parents)
+        obj.requires.append(self)
+        return obj
+
+    def struct(self, name):  # type: (str) -> MockObjClass
+        return self.class_(name)
+
+    def enum(self, name, is_class=False):  # type: (str, bool) -> MockObj
+        if is_class:
+            return self.namespace(name)
+
+        return self
+
+    def operator(self, name):  # type: (str) -> MockObj
+        if name == 'ref':
+            obj = MockObj(u'{} &'.format(self.base), u'')
+            obj.requires.append(self)
+            return obj
+        if name == 'ptr':
+            obj = MockObj(u'{} *'.format(self.base), u'')
+            obj.requires.append(self)
+            return obj
+        if name == "const":
+            obj = MockObj(u'const {}'.format(self.base), u'')
+            obj.requires.append(self)
+            return obj
+        raise NotImplementedError
+
+    def has_side_effects(self):  # type: () -> bool
+        return self._has_side_effects
+
+    def __getitem__(self, item):  # type: (Union[str, Expression]) -> MockObj
+        next_op = u'.'
+        if isinstance(item, str) and item.startswith(u'P'):
+            item = item[1:]
+            next_op = u'->'
+        obj = MockObj(u'{}[{}]'.format(self.base, item), next_op)
+        obj.requires.append(self)
+        if isinstance(item, Expression):
+            obj.requires.append(item)
+        return obj
+
+
+class MockObjClass(MockObj):
+    def __init__(self, *args, **kwargs):
+        parens = kwargs.pop('parents')
+        MockObj.__init__(self, *args, **kwargs)
+        self._parents = []
+        for paren in parens:
+            if not isinstance(paren, MockObjClass):
+                raise ValueError
+            self._parents.append(paren)
+            # pylint: disable=protected-access
+            self._parents += paren._parents
+
+    def inherits_from(self, other):  # type: (MockObjClass) -> bool
+        if self == other:
+            return True
+        for parent in self._parents:
+            if parent == other:
+                return True
+        return False
+
+    def template(self,
+                 *args  # type: Tuple[Union[TemplateArguments, Expression]]
+                 ):
+        # type: (...) -> MockObjClass
+        if len(args) != 1 or not isinstance(args[0], TemplateArguments):
+            args = TemplateArguments(*args)
+        else:
+            args = args[0]
+        new_parents = self._parents[:]
+        new_parents.append(self)
+        obj = MockObjClass(u'{}{}'.format(self.base, args), parents=new_parents)
+        obj.requires.append(self)
+        obj.requires.append(args)
+        return obj

esphome/cpp_helpers.py

@@ -0,0 +1,64 @@
+from esphome.const import CONF_INVERTED, CONF_MODE, CONF_NUMBER, CONF_PCF8574, \
+    CONF_SETUP_PRIORITY, CONF_MCP23017
+from esphome.core import CORE, EsphomeError
+from esphome.cpp_generator import IntLiteral, RawExpression
+from esphome.cpp_types import GPIOInputPin, GPIOOutputPin
+
+
+def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
+    if conf is None:
+        return
+    number = conf[CONF_NUMBER]
+    inverted = conf.get(CONF_INVERTED)
+    if CONF_PCF8574 in conf:
+        from esphome.components import pcf8574
+
+        for hub in CORE.get_variable(conf[CONF_PCF8574]):
+            yield None
+
+        if default_mode == u'INPUT':
+            mode = pcf8574.PCF8675_GPIO_MODES[conf.get(CONF_MODE, u'INPUT')]
+            yield hub.make_input_pin(number, mode, inverted)
+            return
+        if default_mode == u'OUTPUT':
+            yield hub.make_output_pin(number, inverted)
+            return
+
+        raise EsphomeError(u"Unknown default mode {}".format(default_mode))
+    if CONF_MCP23017 in conf:
+        from esphome.components import mcp23017
+
+        for hub in CORE.get_variable(conf[CONF_MCP23017]):
+            yield None
+
+        if default_mode == u'INPUT':
+            mode = mcp23017.MCP23017_GPIO_MODES[conf.get(CONF_MODE, u'INPUT')]
+            yield hub.make_input_pin(number, mode, inverted)
+            return
+        if default_mode == u'OUTPUT':
+            yield hub.make_output_pin(number, inverted)
+            return
+
+        raise EsphomeError(u"Unknown default mode {}".format(default_mode))
+    if len(conf) == 1:
+        yield IntLiteral(number)
+        return
+    mode = RawExpression(conf.get(CONF_MODE, default_mode))
+    yield mock_obj(number, mode, inverted)
+
+
+def gpio_output_pin_expression(conf):
+    for exp in generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT'):
+        yield None
+    yield exp
+
+
+def gpio_input_pin_expression(conf):
+    for exp in generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT'):
+        yield None
+    yield exp
+
+
+def setup_component(obj, config):
+    if CONF_SETUP_PRIORITY in config:
+        CORE.add(obj.set_setup_priority(config[CONF_SETUP_PRIORITY]))

esphome/cpp_types.py

@@ -0,0 +1,36 @@
+from esphome.cpp_generator import MockObj
+
+global_ns = MockObj('', '')
+void = global_ns.namespace('void')
+float_ = global_ns.namespace('float')
+bool_ = global_ns.namespace('bool')
+std_ns = global_ns.namespace('std')
+std_string = std_ns.class_('string')
+std_vector = std_ns.class_('vector')
+uint8 = global_ns.namespace('uint8_t')
+uint16 = global_ns.namespace('uint16_t')
+uint32 = global_ns.namespace('uint32_t')
+int32 = global_ns.namespace('int32_t')
+const_char_ptr = global_ns.namespace('const char *')
+NAN = global_ns.namespace('NAN')
+esphome_ns = global_ns  # using namespace esphome;
+App = esphome_ns.App
+io_ns = esphome_ns.namespace('io')
+Nameable = esphome_ns.class_('Nameable')
+Trigger = esphome_ns.class_('Trigger')
+Action = esphome_ns.class_('Action')
+Component = esphome_ns.class_('Component')
+ComponentPtr = Component.operator('ptr')
+PollingComponent = esphome_ns.class_('PollingComponent', Component)
+Application = esphome_ns.class_('Application')
+optional = esphome_ns.class_('optional')
+arduino_json_ns = global_ns.namespace('ArduinoJson')
+JsonObject = arduino_json_ns.class_('JsonObject')
+JsonObjectRef = JsonObject.operator('ref')
+JsonObjectConstRef = JsonObjectRef.operator('const')
+Controller = esphome_ns.class_('Controller')
+StoringController = esphome_ns.class_('StoringController', Controller)
+
+GPIOPin = esphome_ns.class_('GPIOPin')
+GPIOOutputPin = esphome_ns.class_('GPIOOutputPin', GPIOPin)
+GPIOInputPin = esphome_ns.class_('GPIOInputPin', GPIOPin)

esphome/dashboard/dashboard.py

@@ -0,0 +1,668 @@
+# pylint: disable=wrong-import-position
+from __future__ import print_function
+
+import codecs
+import collections
+import hashlib
+import hmac
+import json
+import logging
+import multiprocessing
+import os
+import shutil
+import subprocess
+import threading
+
+import tornado
+import tornado.concurrent
+import tornado.gen
+import tornado.httpserver
+import tornado.ioloop
+import tornado.iostream
+from tornado.log import access_log
+import tornado.netutil
+import tornado.process
+import tornado.web
+import tornado.websocket
+
+from esphome import const
+from esphome.__main__ import get_serial_ports
+from esphome.helpers import mkdir_p, get_bool_env, run_system_command
+from esphome.py_compat import IS_PY2
+from esphome.storage_json import EsphomeStorageJSON, StorageJSON, \
+    esphome_storage_path, ext_storage_path, trash_storage_path
+from esphome.util import shlex_quote
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import Optional  # noqa
+
+from esphome.zeroconf import DashboardStatus, Zeroconf
+
+_LOGGER = logging.getLogger(__name__)
+CONFIG_DIR = ''
+PASSWORD_DIGEST = ''
+COOKIE_SECRET = None
+USING_PASSWORD = False
+ON_HASSIO = False
+USING_HASSIO_AUTH = True
+HASSIO_MQTT_CONFIG = None
+RELATIVE_URL = os.getenv('ESPHOME_DASHBOARD_RELATIVE_URL', '/')
+STATUS_USE_PING = get_bool_env('ESPHOME_DASHBOARD_USE_PING')
+
+if IS_PY2:
+    cookie_authenticated_yes = 'yes'
+else:
+    cookie_authenticated_yes = b'yes'
+
+
+def template_args():
+    version = const.__version__
+    return {
+        'version': version,
+        'docs_link': 'https://beta.esphome.io/' if 'b' in version else 'https://esphome.io/',
+        'get_static_file_url': get_static_file_url,
+        'relative_url': RELATIVE_URL,
+        'streamer_mode': get_bool_env('ESPHOME_STREAMER_MODE'),
+    }
+
+
+def authenticated(func):
+    def decorator(self, *args, **kwargs):
+        if not self.is_authenticated():
+            self.redirect(RELATIVE_URL + 'login')
+            return None
+        return func(self, *args, **kwargs)
+    return decorator
+
+
+def bind_config(func):
+    def decorator(self, *args, **kwargs):
+        configuration = self.get_argument('configuration')
+        if not is_allowed(configuration):
+            self.set_status(500)
+            return None
+        kwargs = kwargs.copy()
+        kwargs['configuration'] = configuration
+        return func(self, *args, **kwargs)
+    return decorator
+
+
+# pylint: disable=abstract-method
+class BaseHandler(tornado.web.RequestHandler):
+    def is_authenticated(self):
+        if USING_HASSIO_AUTH or USING_PASSWORD:
+            return self.get_secure_cookie('authenticated') == cookie_authenticated_yes
+
+        return True
+
+
+# pylint: disable=abstract-method, arguments-differ
+class EsphomeCommandWebSocket(tornado.websocket.WebSocketHandler):
+    def __init__(self, application, request, **kwargs):
+        super(EsphomeCommandWebSocket, self).__init__(application, request, **kwargs)
+        self.proc = None
+        self.closed = False
+
+    def on_message(self, message):
+        if USING_HASSIO_AUTH or USING_PASSWORD:
+            if self.get_secure_cookie('authenticated') != cookie_authenticated_yes:
+                return
+        if self.proc is not None:
+            return
+        command = self.build_command(message)
+        _LOGGER.info(u"Running command '%s'", ' '.join(shlex_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:
+                if IS_PY2:
+                    reg = '[\n\r]'
+                else:
+                    reg = b'[\n\r]'
+                data = yield self.proc.stdout.read_until_regex(reg)
+                if not IS_PY2:
+                    data = data.decode('utf-8', 'backslashreplace')
+            except tornado.iostream.StreamClosedError:
+                break
+            try:
+                self.write_message({'event': 'line', 'data': data})
+            except UnicodeDecodeError:
+                data = codecs.decode(data, 'utf8', 'replace')
+                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 EsphomeLogsHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = CONFIG_DIR + '/' + js['configuration']
+        return ["esphome", "--dashboard", config_file, "logs", '--serial-port', js["port"]]
+
+
+class EsphomeRunHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "run", '--upload-port', js["port"]]
+
+
+class EsphomeCompileHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "compile"]
+
+
+class EsphomeValidateHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "config"]
+
+
+class EsphomeCleanMqttHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "clean-mqtt"]
+
+
+class EsphomeCleanHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "clean"]
+
+
+class EsphomeHassConfigHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "hass-config"]
+
+
+class SerialPortRequestHandler(BaseHandler):
+    @authenticated
+    def get(self):
+        ports = get_serial_ports()
+        data = []
+        for port, desc in ports:
+            if port == '/dev/ttyAMA0':
+                desc = 'UART pins on GPIO header'
+            split_desc = desc.split(' - ')
+            if len(split_desc) == 2 and split_desc[0] == split_desc[1]:
+                # Some serial ports repeat their values
+                desc = split_desc[0]
+            data.append({'port': port, 'desc': desc})
+        data.append({'port': 'OTA', 'desc': 'Over-The-Air'})
+        data.sort(key=lambda x: x['port'], reverse=True)
+        self.write(json.dumps(data))
+
+
+class WizardRequestHandler(BaseHandler):
+    @authenticated
+    def post(self):
+        from esphome import wizard
+
+        kwargs = {k: ''.join(v) for k, v in self.request.arguments.items()}
+        destination = os.path.join(CONFIG_DIR, kwargs['name'] + '.yaml')
+        wizard.wizard_write(path=destination, **kwargs)
+        self.redirect('/?begin=True')
+
+
+class DownloadBinaryRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def get(self, configuration=None):
+        # pylint: disable=no-value-for-parameter
+        storage_path = ext_storage_path(CONFIG_DIR, configuration)
+        storage_json = StorageJSON.load(storage_path)
+        if storage_json is None:
+            self.send_error()
+            return
+
+        path = storage_json.firmware_bin_path
+        self.set_header('Content-Type', 'application/octet-stream')
+        filename = '{}.bin'.format(storage_json.name)
+        self.set_header("Content-Disposition", 'attachment; filename="{}"'.format(filename))
+        with open(path, 'rb') as f:
+            while True:
+                data = f.read(16384)
+                if not data:
+                    break
+                self.write(data)
+        self.finish()
+
+
+def _list_yaml_files():
+    files = []
+    for file in os.listdir(CONFIG_DIR):
+        if not file.endswith('.yaml'):
+            continue
+        if file.startswith('.'):
+            continue
+        if file == 'secrets.yaml':
+            continue
+        files.append(file)
+    files.sort()
+    return files
+
+
+def _list_dashboard_entries():
+    files = _list_yaml_files()
+    return [DashboardEntry(file) for file in files]
+
+
+class DashboardEntry(object):
+    def __init__(self, filename):
+        self.filename = filename
+        self._storage = None
+        self._loaded_storage = False
+
+    @property
+    def full_path(self):  # type: () -> str
+        return os.path.join(CONFIG_DIR, self.filename)
+
+    @property
+    def storage(self):  # type: () -> Optional[StorageJSON]
+        if not self._loaded_storage:
+            self._storage = StorageJSON.load(ext_storage_path(CONFIG_DIR, self.filename))
+            self._loaded_storage = True
+        return self._storage
+
+    @property
+    def address(self):
+        if self.storage is None:
+            return None
+        return self.storage.address
+
+    @property
+    def name(self):
+        if self.storage is None:
+            return self.filename[:-len('.yaml')]
+        return self.storage.name
+
+    @property
+    def esp_platform(self):
+        if self.storage is None:
+            return None
+        return self.storage.esp_platform
+
+    @property
+    def board(self):
+        if self.storage is None:
+            return None
+        return self.storage.board
+
+    @property
+    def update_available(self):
+        if self.storage is None:
+            return True
+        return self.update_old != self.update_new
+
+    @property
+    def update_old(self):
+        if self.storage is None:
+            return ''
+        return self.storage.esphome_version or ''
+
+    @property
+    def update_new(self):
+        return const.__version__
+
+
+class MainRequestHandler(BaseHandler):
+    @authenticated
+    def get(self):
+        begin = bool(self.get_argument('begin', False))
+        entries = _list_dashboard_entries()
+
+        self.render("templates/index.html", entries=entries, begin=begin,
+                    **template_args())
+
+
+def _ping_func(filename, address):
+    if os.name == 'nt':
+        command = ['ping', '-n', '1', address]
+    else:
+        command = ['ping', '-c', '1', address]
+    rc, _, _ = run_system_command(*command)
+    return filename, rc == 0
+
+
+class MDNSStatusThread(threading.Thread):
+    def run(self):
+        zc = Zeroconf()
+
+        def on_update(dat):
+            for key, b in dat.items():
+                PING_RESULT[key] = b
+
+        stat = DashboardStatus(zc, on_update)
+        stat.start()
+        while not STOP_EVENT.is_set():
+            entries = _list_dashboard_entries()
+            stat.request_query({entry.filename: entry.name + '.local.' for entry in entries})
+
+            PING_REQUEST.wait()
+            PING_REQUEST.clear()
+        stat.stop()
+        stat.join()
+        zc.close()
+
+
+class PingStatusThread(threading.Thread):
+    def run(self):
+        pool = multiprocessing.Pool(processes=8)
+        while not STOP_EVENT.is_set():
+            # Only do pings if somebody has the dashboard open
+
+            def callback(ret):
+                PING_RESULT[ret[0]] = ret[1]
+
+            entries = _list_dashboard_entries()
+            queue = collections.deque()
+            for entry in entries:
+                if entry.address is None:
+                    PING_RESULT[entry.filename] = None
+                    continue
+
+                result = pool.apply_async(_ping_func, (entry.filename, entry.address),
+                                          callback=callback)
+                queue.append(result)
+
+            while queue:
+                item = queue[0]
+                if item.ready():
+                    queue.popleft()
+                    continue
+
+                try:
+                    item.get(0.1)
+                except OSError:
+                    # ping not installed
+                    pass
+                except multiprocessing.TimeoutError:
+                    pass
+
+                if STOP_EVENT.is_set():
+                    pool.terminate()
+                    return
+
+            PING_REQUEST.wait()
+            PING_REQUEST.clear()
+
+
+class PingRequestHandler(BaseHandler):
+    @authenticated
+    def get(self):
+        PING_REQUEST.set()
+        self.write(json.dumps(PING_RESULT))
+
+
+def is_allowed(configuration):
+    return os.path.sep not in configuration
+
+
+class EditRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def get(self, configuration=None):
+        # pylint: disable=no-value-for-parameter
+        with open(os.path.join(CONFIG_DIR, configuration), 'r') as f:
+            content = f.read()
+        self.write(content)
+
+    @authenticated
+    @bind_config
+    def post(self, configuration=None):
+        # pylint: disable=no-value-for-parameter
+        with open(os.path.join(CONFIG_DIR, configuration), 'wb') as f:
+            f.write(self.request.body)
+        self.set_status(200)
+
+
+class DeleteRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def post(self, configuration=None):
+        config_file = os.path.join(CONFIG_DIR, configuration)
+        storage_path = ext_storage_path(CONFIG_DIR, configuration)
+        storage_json = StorageJSON.load(storage_path)
+        if storage_json is None:
+            self.set_status(500)
+            return
+
+        name = storage_json.name
+        trash_path = trash_storage_path(CONFIG_DIR)
+        mkdir_p(trash_path)
+        shutil.move(config_file, os.path.join(trash_path, configuration))
+
+        # Delete build folder (if exists)
+        build_folder = os.path.join(CONFIG_DIR, name)
+        if build_folder is not None:
+            shutil.rmtree(build_folder, os.path.join(trash_path, name))
+
+
+class UndoDeleteRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def post(self, configuration=None):
+        config_file = os.path.join(CONFIG_DIR, configuration)
+        trash_path = trash_storage_path(CONFIG_DIR)
+        shutil.move(os.path.join(trash_path, configuration), config_file)
+
+
+PING_RESULT = {}  # type: dict
+STOP_EVENT = threading.Event()
+PING_REQUEST = threading.Event()
+
+
+class LoginHandler(BaseHandler):
+    def get(self):
+        if USING_HASSIO_AUTH:
+            self.render_hassio_login()
+            return
+        self.write('<html><body><form action="' + RELATIVE_URL + 'login" method="post">'
+                   'Password: <input type="password" name="password">'
+                   '<input type="submit" value="Sign in">'
+                   '</form></body></html>')
+
+    def render_hassio_login(self, error=None):
+        self.render("templates/login.html", error=error, **template_args())
+
+    def post_hassio_login(self):
+        import requests
+
+        headers = {
+            'X-HASSIO-KEY': os.getenv('HASSIO_TOKEN'),
+        }
+        data = {
+            'username': str(self.get_argument('username', '')),
+            'password': str(self.get_argument('password', ''))
+        }
+        try:
+            req = requests.post('http://hassio/auth', headers=headers, data=data)
+            if req.status_code == 200:
+                self.set_secure_cookie("authenticated", cookie_authenticated_yes)
+                self.redirect('/')
+                return
+        except Exception as err:  # pylint: disable=broad-except
+            _LOGGER.warning("Error during Hass.io auth request: %s", err)
+            self.set_status(500)
+            self.render_hassio_login(error="Internal server error")
+            return
+        self.set_status(401)
+        self.render_hassio_login(error="Invalid username or password")
+
+    def post(self):
+        if USING_HASSIO_AUTH:
+            self.post_hassio_login()
+            return
+
+        password = str(self.get_argument("password", ''))
+        if IS_PY2:
+            password = hmac.new(password).digest()
+        else:
+            password = hmac.new(password.encode()).digest()
+        if hmac.compare_digest(PASSWORD_DIGEST, password):
+            self.set_secure_cookie("authenticated", cookie_authenticated_yes)
+        self.redirect("/")
+
+
+_STATIC_FILE_HASHES = {}
+
+
+def get_static_file_url(name):
+    static_path = os.path.join(os.path.dirname(__file__), 'static')
+    if name in _STATIC_FILE_HASHES:
+        hash_ = _STATIC_FILE_HASHES[name]
+    else:
+        path = os.path.join(static_path, name)
+        with open(path, 'rb') as f_handle:
+            hash_ = hashlib.md5(f_handle.read()).hexdigest()[:8]
+        _STATIC_FILE_HASHES[name] = hash_
+    return RELATIVE_URL + u'static/{}?hash={}'.format(name, hash_)
+
+
+def make_app(debug=False):
+    def log_function(handler):
+        if handler.get_status() < 400:
+            log_method = access_log.info
+
+            if isinstance(handler, SerialPortRequestHandler) and not debug:
+                return
+            if isinstance(handler, PingRequestHandler) and not debug:
+                return
+        elif handler.get_status() < 500:
+            log_method = access_log.warning
+        else:
+            log_method = access_log.error
+
+        request_time = 1000.0 * handler.request.request_time()
+        # pylint: disable=protected-access
+        log_method("%d %s %.2fms", handler.get_status(),
+                   handler._request_summary(), request_time)
+
+    class StaticFileHandler(tornado.web.StaticFileHandler):
+        def set_extra_headers(self, path):
+            if debug:
+                self.set_header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
+
+    static_path = os.path.join(os.path.dirname(__file__), 'static')
+    settings = {
+        'debug': debug,
+        'cookie_secret': COOKIE_SECRET,
+        'log_function': log_function,
+        'websocket_ping_interval': 30.0,
+    }
+    app = tornado.web.Application([
+        (RELATIVE_URL + "", MainRequestHandler),
+        (RELATIVE_URL + "login", LoginHandler),
+        (RELATIVE_URL + "logs", EsphomeLogsHandler),
+        (RELATIVE_URL + "run", EsphomeRunHandler),
+        (RELATIVE_URL + "compile", EsphomeCompileHandler),
+        (RELATIVE_URL + "validate", EsphomeValidateHandler),
+        (RELATIVE_URL + "clean-mqtt", EsphomeCleanMqttHandler),
+        (RELATIVE_URL + "clean", EsphomeCleanHandler),
+        (RELATIVE_URL + "hass-config", EsphomeHassConfigHandler),
+        (RELATIVE_URL + "edit", EditRequestHandler),
+        (RELATIVE_URL + "download.bin", DownloadBinaryRequestHandler),
+        (RELATIVE_URL + "serial-ports", SerialPortRequestHandler),
+        (RELATIVE_URL + "ping", PingRequestHandler),
+        (RELATIVE_URL + "delete", DeleteRequestHandler),
+        (RELATIVE_URL + "undo-delete", UndoDeleteRequestHandler),
+        (RELATIVE_URL + "wizard.html", WizardRequestHandler),
+        (RELATIVE_URL + r"static/(.*)", StaticFileHandler, {'path': static_path}),
+    ], **settings)
+
+    if debug:
+        _STATIC_FILE_HASHES.clear()
+
+    return app
+
+
+def start_web_server(args):
+    global CONFIG_DIR
+    global PASSWORD_DIGEST
+    global USING_PASSWORD
+    global ON_HASSIO
+    global USING_HASSIO_AUTH
+    global COOKIE_SECRET
+
+    CONFIG_DIR = args.configuration
+    mkdir_p(CONFIG_DIR)
+    mkdir_p(os.path.join(CONFIG_DIR, ".esphome"))
+
+    ON_HASSIO = args.hassio
+    if ON_HASSIO:
+        USING_HASSIO_AUTH = not get_bool_env('DISABLE_HA_AUTHENTICATION')
+        USING_PASSWORD = False
+    else:
+        USING_HASSIO_AUTH = False
+        USING_PASSWORD = args.password
+
+    if USING_PASSWORD:
+        if IS_PY2:
+            PASSWORD_DIGEST = hmac.new(args.password).digest()
+        else:
+            PASSWORD_DIGEST = hmac.new(args.password.encode()).digest()
+
+    if USING_HASSIO_AUTH or USING_PASSWORD:
+        path = esphome_storage_path(CONFIG_DIR)
+        storage = EsphomeStorageJSON.load(path)
+        if storage is None:
+            storage = EsphomeStorageJSON.get_default()
+            storage.save(path)
+        COOKIE_SECRET = storage.cookie_secret
+
+    app = make_app(args.verbose)
+    if args.socket is not None:
+        _LOGGER.info("Starting dashboard web server on unix socket %s and configuration dir %s...",
+                     args.socket, CONFIG_DIR)
+        server = tornado.httpserver.HTTPServer(app)
+        socket = tornado.netutil.bind_unix_socket(args.socket, mode=0o666)
+        server.add_socket(socket)
+    else:
+        _LOGGER.info("Starting dashboard web server on port %s and configuration dir %s...",
+                     args.port, CONFIG_DIR)
+        app.listen(args.port)
+
+        if args.open_ui:
+            import webbrowser
+
+            webbrowser.open('localhost:{}'.format(args.port))
+
+    if STATUS_USE_PING:
+        status_thread = PingStatusThread()
+    else:
+        status_thread = MDNSStatusThread()
+    status_thread.start()
+    try:
+        tornado.ioloop.IOLoop.current().start()
+    except KeyboardInterrupt:
+        _LOGGER.info("Shutting down...")
+        STOP_EVENT.set()
+        PING_REQUEST.set()
+        status_thread.join()
+        if args.socket is not None:
+            os.remove(args.socket)

esphome/dashboard/static/esphome.css

@@ -0,0 +1,244 @@
+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;
+}
+
+.card-action a, .card-dropdown-action a {
+  cursor: pointer;
+}
+
+.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 {
+  max-height: calc(100% - 56px);
+  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;
+}
+
+.log-bold { font-weight: bold; }
+.log-italic { font-style: italic; }
+.log-underline { text-decoration: underline; }
+.log-strikethrough { text-decoration: line-through; }
+.log-underline.log-strikethrough { text-decoration: underline line-through; }
+.log-secret {
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+.log-secret-redacted {
+  opacity: 0;
+  width: 1px;
+  font-size: 1px;
+}
+.log-fg-black { color: rgb(128,128,128); }
+.log-fg-red { color: rgb(255,0,0); }
+.log-fg-green { color: rgb(0,255,0); }
+.log-fg-yellow { color: rgb(255,255,0); }
+.log-fg-blue { color: rgb(0,0,255); }
+.log-fg-magenta { color: rgb(255,0,255); }
+.log-fg-cyan { color: rgb(0,255,255); }
+.log-fg-white { color: rgb(187,187,187); }
+.log-bg-black { background-color: rgb(0,0,0); }
+.log-bg-red { background-color: rgb(255,0,0); }
+.log-bg-green { background-color: rgb(0,255,0); }
+.log-bg-yellow { background-color: rgb(255,255,0); }
+.log-bg-blue { background-color: rgb(0,0,255); }
+.log-bg-magenta { background-color: rgb(255,0,255); }
+.log-bg-cyan { background-color: rgb(0,255,255); }
+.log-bg-white { background-color: rgb(255,255,255); }
+
+.modal {
+  width: 95%;
+  max-height: 90%;
+  height: 85% !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: 8px;
+  margin-right: 24px;
+  width: 350px;
+}
+
+.select-port-container .select-dropdown {
+  color: #fff;
+}
+
+.select-port-container .caret {
+  fill: #fff;
+}
+
+.dropdown-trigger {
+  cursor: pointer;
+}
+
+.select-action {
+  width: auto !important;
+  height: auto !important;
+  white-space: nowrap;
+}
+
+.tap-target-wrapper {
+  position: fixed !important;
+}
+
+/* https://github.com/tnhu/status-indicator/blob/master/styles.css */
+.status-indicator .status-indicator-icon {
+  display: inline-block;
+  border-radius: 50%;
+  width: 10px;
+  height: 10px;
+}
+
+.status-indicator.unknown .status-indicator-icon {
+  background-color: rgb(216, 226, 233);
+}
+
+.status-indicator.unknown .status-indicator-text::after {
+  content: "Unknown status";
+}
+
+.status-indicator.offline .status-indicator-icon {
+  background-color: rgb(255, 77, 77);
+}
+
+.status-indicator.offline .status-indicator-text::after {
+  content: "Offline";
+}
+
+.status-indicator.not-responding .status-indicator-icon {
+  background-color: rgb(255, 170, 0);
+}
+
+.status-indicator.not-responding .status-indicator-text::after {
+  content: "Not Responding";
+}
+
+@keyframes status-indicator-pulse-online {
+  0%   {
+    box-shadow: 0 0 0 0 rgba(75, 210, 143, .5);
+  }
+  25%  {
+    box-shadow: 0 0 0 10px rgba(75, 210, 143, 0);
+  }
+  30% {
+    box-shadow: 0 0 0 0 rgba(75, 210, 143, 0);
+  }
+}
+
+.status-indicator.online .status-indicator-icon {
+  background-color: rgb(75, 210, 143);
+  animation-duration: 5s;
+  animation-timing-function: ease-in-out;
+  animation-iteration-count: infinite;
+  animation-direction: normal;
+  animation-delay: 0s;
+  animation-fill-mode: none;
+  animation-name: status-indicator-pulse-online;
+}
+
+.status-indicator.online .status-indicator-text::after {
+  content: "Online";
+}
+
+#editor {
+  margin-top: 0;
+  margin-bottom: 0;
+  border-radius: 3px;
+  height: calc(100% - 56px);
+}
+
+.update-available i {
+  vertical-align: bottom;
+  font-size: 20px !important;
+  color: #3F51B5 !important;
+  margin-right: -4.5px;
+  margin-left: -5.5px;
+}
+
+.flash-using-esphomeflasher {
+  vertical-align: middle;
+  color: #666 !important;
+}
+
+.error {
+  background: #e53935;
+  color: #fff;
+  padding: 10px 15px;
+  margin-top: 15px;
+}