Bump HassIO version to v1.9.3

* CSE7766 update interval

* PollingComponent

.dockerignore

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,47 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+<!-- Thanks for reporting a bug for this project. READ THIS FIRST:
+- Please make sure to submit issues in the right GitHub repository, if unsure just post it here:
+  - esphomeyaml [here] - This is mostly for reporting bugs when compiling and when you get a long stack trace while compiling or if a configuration fails to validate.
+  - esphomelib [https://github.com/OttoWinter/esphomelib] - Report bugs there if the ESP is crashing or a feature is not working as expected.
+  - esphomedocs [https://github.com/OttoWinter/esphomedocs] - Report bugs there if the documentation is wrong/outdated.
+- Provide as many details as possible. Paste logs, configuration sample and code into the backticks (```). Do not delete any text from this template!
+-->
+
+**Operating environment (Hass.io/Docker/pip/etc.):**
+<!--
+Please provide details about your environment.
+-->
+
+**ESP (ESP32/ESP8266/Board/Sonoff):**
+<!--
+Please provide details about which ESP you're using.
+-->
+
+**Affected component:**
+<!--
+Please add the link to the documentation at https://esphomelib.com/esphomeyaml/index.html of the component in question.
+-->
+
+
+**Description of problem:**
+
+
+**Problem-relevant YAML-configuration entries:**
+```yaml
+
+```
+
+**Traceback (if applicable):**
+<!--
+Please copy the traceback here if compilation is failing. If possible, also connect to the ESP and copy its logs into the backticks.
+-->
+```
+
+```
+
+**Additional information:**

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,22 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+<!-- READ THIS FIRST:
+ - This is for feature requests only, if you want to have a certain new sensor/module supported, please use the "new integration" template.
+ - Please be as descriptive as possible, especially use-cases that can otherwise not be solved boost the problem's priority.
+-->
+
+**Is your feature request related to a problem? Please describe.**
+<!-- 
+A clear and concise description of what the problem is. 
+-->
+Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A description of what you want to happen.
+
+**Additional context**
+Add any other context about the feature request here.

.github/ISSUE_TEMPLATE/new-integration.md

@@ -0,0 +1,20 @@
+---
+name: New integration
+about: Suggest a new integration for esphomelib
+
+---
+
+<!-- READ THIS FIRST:
+ - This is for new integrations (such as new sensors/modules) only, for new features within the environment please use the "feature request" template.
+ - Do not delete anything from this template and fill out the form as precisely as possible.
+-->
+
+**What new integration would you wish to have?**
+<!-- A name/description of the new integration/board. -->
+
+**If possible, provide a link to an existing library for the integration:**
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Additional context**

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,20 @@
+## Description:
+
+
+**Related issue (if applicable):** fixes <link to issue>
+
+**Pull request in [esphomedocs](https://github.com/OttoWinter/esphomedocs) with documentation (if applicable):** OttoWinter/esphomedocs#<esphomedocs PR number goes here>
+**Pull request in [esphomelib](https://github.com/OttoWinter/esphomelib) with C++ framework changes (if applicable):** OttoWinter/esphomelib#<esphomelib PR number goes here>
+
+## Example entry for YAML configuration (if applicable):
+```yaml
+
+```
+
+## Checklist:
+  - [ ] The code change is tested and works locally.
+  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).
+  - [ ] Check this box if you have read, understand, comply, and agree with the [Code of Conduct](https://github.com/OttoWinter/esphomeyaml/blob/master/CODE_OF_CONDUCT.md).
+
+If user exposed functionality or configuration variables are added/changed:
+  - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

.gitignore

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

.gitlab-ci.yml

@@ -0,0 +1,320 @@
+---
+# Based on https://gitlab.com/hassio-addons/addon-node-red/blob/master/.gitlab-ci.yml
+variables:
+  DOCKER_DRIVER: overlay2
+
+stages:
+  - lint
+  - test
+  - build
+  - deploy
+
+.lint: &lint
+  stage: lint
+  tags:
+    - python2.7
+    - esphomeyaml-lint
+
+.test: &test
+  stage: test
+  before_script:
+    - pip install -e .
+  tags:
+    - python2.7
+    - esphomeyaml-test
+  variables:
+    TZ: UTC
+  cache:
+    paths:
+      - tests/build
+
+.docker-builder: &docker-builder
+  before_script:
+    - docker info
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
+  services:
+    - docker:dind
+  tags:
+    - hassio-builder
+
+flake8:
+  <<: *lint
+  script:
+    - flake8 esphomeyaml
+
+pylint:
+  <<: *lint
+  script:
+    - pylint esphomeyaml
+
+test1:
+  <<: *test
+  script:
+    - esphomeyaml tests/test1.yaml compile
+
+test2:
+  <<: *test
+  script:
+    - esphomeyaml tests/test2.yaml compile
+
+.build-hassio: &build-hassio
+  <<: *docker-builder
+  stage: build
+  script:
+    - docker run --rm --privileged hassioaddons/qemu-user-static:latest
+    - BUILD_FROM=homeassistant/${ADDON_ARCH}-base-ubuntu:latest
+    - ADDON_VERSION="${CI_COMMIT_TAG#v}"
+    - ADDON_VERSION="${ADDON_VERSION:-${CI_COMMIT_SHA:0:7}}"
+    - ESPHOMELIB_VERSION="${ESPHOMELIB_VERSION:-dev}"
+    - echo "Build from ${BUILD_FROM}"
+    - echo "Add-on version ${ADDON_VERSION}"
+    - echo "Esphomelib version ${ESPHOMELIB_VERSION}"
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:dev"
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - |
+      docker build \
+        --build-arg "BUILD_FROM=${BUILD_FROM}" \
+        --build-arg "ADDON_ARCH=${ADDON_ARCH}" \
+        --build-arg "ADDON_VERSION=${ADDON_VERSION}" \
+        --build-arg "ESPHOMELIB_VERSION=${ESPHOMELIB_VERSION}" \
+        --tag "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:dev" \
+        --tag "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        --file "docker/Dockerfile.hassio" \
+        .
+    - |
+      if [ "${DO_PUSH:-true}" = true ]; then
+        echo "Pushing to CI registry"
+        docker push ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}
+        docker push ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:dev
+      fi
+
+# Generic deploy template
+.deploy-release: &deploy-release
+  <<: *docker-builder
+  stage: deploy
+  script:
+    - version="${CI_COMMIT_TAG#v}"
+    - echo "Publishing release version ${version}"
+    - docker pull "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
+
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+
+    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+
+    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+
+    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+  only:
+  - /^v\d+\.\d+\.\d+$/
+  except:
+  - /^(?!master).+@/
+
+.deploy-beta: &deploy-beta
+  <<: *docker-builder
+  stage: deploy
+  script:
+    - version="${CI_COMMIT_TAG#v}"
+    - echo "Publishing beta version ${version}"
+    - docker pull "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
+
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+
+    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+
+    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+
+    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+  only:
+  - /^v\d+\.\d+\.\d+b\d+$/
+  except:
+  - /^(?!rc).+@/
+
+# Build jobs
+build:normal:
+  <<: *docker-builder
+  stage: build
+  script:
+    - docker build -t "${CI_REGISTRY}/esphomeyaml:dev" .
+
+.build-hassio-edge: &build-hassio-edge
+  <<: *build-hassio
+  except:
+    - /^v\d+\.\d+\.\d+$/
+    - /^v\d+\.\d+\.\d+b\d+$/
+
+.build-hassio-release: &build-hassio-release
+  <<: *build-hassio
+  only:
+    - /^v\d+\.\d+\.\d+$/
+    - /^v\d+\.\d+\.\d+b\d+$/
+
+build:hassio-armhf-edge:
+  <<: *build-hassio-edge
+  variables:
+    ADDON_ARCH: armhf
+    DO_PUSH: "false"
+
+build:hassio-armhf:
+  <<: *build-hassio-release
+  variables:
+    ADDON_ARCH: armhf
+    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
+
+#build:hassio-aarch64-edge:
+#  <<: *build-hassio-edge
+#  variables:
+#    ADDON_ARCH: aarch64
+#    DO_PUSH: "false"
+
+#build:hassio-aarch64:
+#  <<: *build-hassio-release
+#  variables:
+#    ADDON_ARCH: aarch64
+#    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
+
+build:hassio-i386-edge:
+  <<: *build-hassio-edge
+  variables:
+    ADDON_ARCH: i386
+    DO_PUSH: "false"
+
+build:hassio-i386:
+  <<: *build-hassio-release
+  variables:
+    ADDON_ARCH: i386
+    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
+
+build:hassio-amd64-edge:
+  <<: *build-hassio-edge
+  variables:
+    ADDON_ARCH: amd64
+    DO_PUSH: "false"
+
+build:hassio-amd64:
+  <<: *build-hassio-release
+  variables:
+    ADDON_ARCH: amd64
+    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
+
+# Deploy jobs
+deploy-release:armhf:
+  <<: *deploy-release
+  variables:
+    ADDON_ARCH: armhf
+
+deploy-beta:armhf:
+  <<: *deploy-beta
+  variables:
+    ADDON_ARCH: armhf
+
+#deploy-release:aarch64:
+#  <<: *deploy-release
+#  variables:
+#    ADDON_ARCH: aarch64
+#
+#deploy-beta:aarch64:
+#  <<: *deploy-beta
+#  variables:
+#    ADDON_ARCH: aarch64
+
+deploy-release:i386:
+  <<: *deploy-release
+  variables:
+    ADDON_ARCH: i386
+
+deploy-beta:i386:
+  <<: *deploy-beta
+  variables:
+    ADDON_ARCH: i386
+
+deploy-release:amd64:
+  <<: *deploy-release
+  variables:
+    ADDON_ARCH: amd64
+
+deploy-beta:amd64:
+  <<: *deploy-beta
+  variables:
+    ADDON_ARCH: amd64
+
+.deploy-pypi: &deploy-pypi
+  stage: deploy
+  before_script:
+  - pip install -e .
+  - pip install twine
+  script:
+  - python setup.py sdist
+  - twine upload dist/*
+  tags:
+  - python2.7
+  - esphomeyaml-test
+
+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).+@/

.travis.yml

@@ -0,0 +1,20 @@
+sudo: false
+language: python
+python:
+  - "2.7"
+jobs:
+  include:
+    - name: "Lint"
+      install:
+        - pip install -r requirements.txt
+        - pip install flake8==3.5.0 pylint==1.9.3 tzlocal pillow
+      script:
+        - flake8 esphomeyaml
+        - pylint esphomeyaml
+    - name: "Test"
+      install:
+        - pip install -e .
+        - pip install tzlocal pillow
+      script:
+        - esphomeyaml tests/test1.yaml compile
+        - esphomeyaml 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 esphomeyaml
+
+esphomeyaml is a part of esphomelib and 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 [esphomelib](https://github.com/OttoWinter/esphomelib), the C++ framework behind the project.
+
+For a detailed guide, please see https://esphomelib.com/esphomeyaml/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/OttoWinter/esphomedocs). See [contributing to esphomedocs](https://esphomelib.com/esphomeyaml/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,25 +1,29 @@
-FROM python:2.7
+ARG BUILD_FROM=python:2.7
+FROM ${BUILD_FROM}
 MAINTAINER Otto Winter <contact@otto-winter.com>
 
+RUN apt-get update && apt-get install -y \
+        python-pil \
+        git \
+    && apt-get clean && 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
+
 ENV ESPHOMEYAML_OTA_HOST_PORT=6123
 EXPOSE 6123
 VOLUME /config
 WORKDIR /usr/src/app
 
-COPY requirements.txt /usr/src/app/
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY docker/platformio.ini /usr/src/app/
-RUN platformio settings set enable_telemetry No && \
-    platformio lib --global install esphomelib=https://github.com/OttoWinter/esphomelib.git#v1.2.1 && \
-    platformio run -e espressif32 -e espressif8266; exit 0
-
-# Fix issue with static IP on ESP32: https://github.com/espressif/arduino-esp32/issues/1081
-RUN curl https://github.com/espressif/arduino-esp32/commit/144480637a718844b8f48f4392da8d4f622f2e5e.patch | \
-    patch /root/.platformio/packages/framework-arduinoespressif32/libraries/WiFi/src/WiFiGeneric.cpp
+COPY docker/platformio.ini /pio/platformio.ini
+RUN platformio run -d /pio; rm -rf /pio
 
 COPY . .
-RUN pip install -e .
+RUN pip install --no-cache-dir --no-binary :all: -e . && \
+    pip install --no-cache-dir --no-binary :all: tzlocal
 
 WORKDIR /config
 ENTRYPOINT ["esphomeyaml"]
+CMD ["/config", "dashboard"]

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,4 @@
+include README.md
+include esphomeyaml/dashboard/templates/index.html
+include esphomeyaml/dashboard/static/materialize-stepper.min.css
+include esphomeyaml/dashboard/static/materialize-stepper.min.js

README.md

@@ -1,10 +1,10 @@
 # esphomeyaml for [esphomelib](https://github.com/OttoWinter/esphomelib)
 
-### Getting Started Guide: https://esphomelib.com/esphomeyaml/getting-started.html
+### Getting Started Guide: https://esphomelib.com/esphomeyaml/guides/getting_started_command_line.html
 
 ### Available Components: https://esphomelib.com/esphomeyaml/index.html
 
-esphomeyaml is the solution for your ESP8266/ESP32 projects with Home Assistant. It allows you to create **custom firmwares** for your microcontrollers with no programming experience required. All you need to know is the YAML configuration format which is also used by Home Assistant.
+esphomeyaml 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](https://www.home-assistant.io).
 
 esphomeyaml will:
 
@@ -26,7 +26,7 @@ esphomeyaml configuration.yaml run
     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.
+ * **Made for [Home Assistant](https://www.home-assistant.io):** Almost all [Home Assistant](https://www.home-assistant.io) 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.

docker/Dockerfile.builder

@@ -0,0 +1,30 @@
+FROM multiarch/ubuntu-core:amd64-xenial
+
+# setup locals
+RUN apt-get update && apt-get install -y \
+        jq \
+        git \
+        python3-setuptools \
+    && rm -rf /var/lib/apt/lists/* \
+ENV LANG C.UTF-8
+
+# Install docker
+# https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/
+RUN apt-get update && apt-get install -y \
+        apt-transport-https \
+        ca-certificates \
+        curl \
+        software-properties-common \
+    && rm -rf /var/lib/apt/lists/* \
+    && curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add - \
+    && add-apt-repository "deb https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
+    && apt-get update && apt-get install -y docker-ce \
+    && rm -rf /var/lib/apt/lists/*
+
+# setup arm binary support
+RUN apt-get update && apt-get install -y \
+        qemu-user-static \
+        binfmt-support \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /data

docker/Dockerfile.hassio

@@ -0,0 +1,42 @@
+# Dockerfile for HassIO add-on
+ARG BUILD_FROM=homeassistant/amd64-base-ubuntu:latest
+FROM ${BUILD_FROM}
+
+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/* && \
+    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
+
+ARG ESPHOMELIB_VERSION="dev"
+RUN platformio lib -g install "https://github.com/OttoWinter/esphomelib.git#${ESPHOMELIB_VERSION}"
+
+COPY . .
+RUN pip install --no-cache-dir --no-binary :all: -e . && \
+    pip install --no-cache-dir --no-binary :all: tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]
+
+# Build arugments
+ARG ADDON_ARCH
+ARG ADDON_VERSION
+
+# Labels
+LABEL \
+    io.hass.name="esphomeyaml" \
+    io.hass.description="esphomeyaml HassIO add-on for intelligently managing all your ESP8266/ESP32 devices." \
+    io.hass.arch="${ADDON_ARCH}" \
+    io.hass.type="addon" \
+    io.hass.version="${ADDON_VERSION}" \
+    io.hass.url="https://esphomelib.com/esphomeyaml/index.html" \
+    maintainer="Otto Winter <contact@otto-winter.com>"

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.5.0 pylint==1.9.3 tzlocal pillow

docker/Dockerfile.test

@@ -0,0 +1,19 @@
+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
+
+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 && \
+    pip install --no-cache-dir tzlocal pillow

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
 board = nodemcuv2
 framework = arduino
+
+[env:espressif32]
+platform = espressif32
+board = nodemcu-32s
+framework = arduino

esphomeyaml-beta/config.json

@@ -0,0 +1,33 @@
+{
+  "name": "esphomeyaml-beta",
+  "version": "1.9.3",
+  "slug": "esphomeyaml-beta",
+  "description": "Beta version of esphomeyaml HassIO add-on.",
+  "url": "https://beta.esphomelib.com/esphomeyaml/index.html",
+  "startup": "application",
+  "webui": "http://[HOST]:[PORT:6052]",
+  "boot": "auto",
+  "ports": {
+    "6052/tcp": 6052,
+    "6053/tcp": 6053
+  },
+  "auto_uart": true,
+  "map": [
+    "config:rw"
+  ],
+  "arch": [
+    "amd64",
+    "armhf",
+    "i386"
+  ],
+  "environment": {
+    "ESPHOMEYAML_OTA_HOST_PORT": "6053"
+  },
+  "options": {
+    "password": ""
+  },
+  "schema": {
+    "password": "str?"
+  },
+  "image": "ottowinter/esphomeyaml-hassio-{arch}"
+}

esphomeyaml-edge/Dockerfile

@@ -0,0 +1,24 @@
+# Dockerfile for HassIO edge add-on
+ARG BUILD_FROM=homeassistant/amd64-base-ubuntu:latest
+FROM ${BUILD_FROM}
+
+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/* && \
+    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 platformio.ini /pio/platformio.ini
+RUN platformio run -d /pio; rm -rf /pio
+
+RUN pip install --no-cache-dir git+https://github.com/OttoWinter/esphomeyaml.git@dev#egg=esphomeyaml && \
+    pip install --no-cache-dir pillow tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

esphomeyaml-edge/build.json

@@ -0,0 +1,10 @@
+{
+    "squash": false,
+    "build_from": {
+        "aarch64": "homeassistant/aarch64-base-ubuntu:latest",
+        "amd64": "homeassistant/amd64-base-ubuntu:latest",
+        "armhf": "homeassistant/armhf-base-ubuntu:latest",
+        "i386": "homeassistant/i386-base-ubuntu:latest"
+    },
+    "args": {}
+}

esphomeyaml-edge/config.json

@@ -0,0 +1,33 @@
+{
+  "name": "esphomeyaml-edge",
+  "version": "dev",
+  "slug": "esphomeyaml-edge",
+  "description": "Development build of the esphomeyaml HassIO add-on.",
+  "url": "https://esphomelib.com/esphomeyaml/index.html",
+  "startup": "application",
+  "webui": "http://[HOST]:[PORT:6052]",
+  "boot": "auto",
+  "ports": {
+    "6052/tcp": 6052,
+    "6053/tcp": 6053
+  },
+  "arch": [
+    "aarch64",
+    "amd64",
+    "armhf",
+    "i386"
+  ],
+  "auto_uart": true,
+  "map": [
+    "config:rw"
+  ],
+  "options": {
+    "password": ""
+  },
+  "schema": {
+    "password": "str?"
+  },
+  "environment": {
+    "ESPHOMEYAML_OTA_HOST_PORT": "6053"
+  }
+}

esphomeyaml-edge/platformio.ini

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

esphomeyaml/__main__.py

@@ -1,178 +1,217 @@
 from __future__ import print_function
 
 import argparse
+from collections import OrderedDict
 import logging
 import os
 import random
 import sys
+from datetime import datetime
 
-from esphomeyaml import helpers, mqtt, writer, yaml_util, wizard
-from esphomeyaml.config import add_component_task, read_config
-from esphomeyaml.const import CONF_ESPHOMEYAML, CONF_HOSTNAME, CONF_MANUAL_IP, CONF_NAME, \
-    CONF_STATIC_IP, \
-    CONF_WIFI, CONF_LOGGER, CONF_BAUD_RATE
-from esphomeyaml.helpers import AssignmentExpression, RawStatement, _EXPRESSIONS, add, \
-    get_variable, indent, quote, statement
+from esphomeyaml import const, core, core_config, mqtt, wizard, writer, yaml_util, platformio_api
+from esphomeyaml.config import get_component, iter_components, read_config
+from esphomeyaml.const import CONF_BAUD_RATE, CONF_BUILD_PATH, CONF_DOMAIN, CONF_ESPHOMEYAML, \
+    CONF_HOSTNAME, CONF_LOGGER, CONF_MANUAL_IP, CONF_NAME, CONF_STATIC_IP, CONF_USE_CUSTOM_CODE, \
+    CONF_WIFI, ESP_PLATFORM_ESP8266
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import AssignmentExpression, Expression, RawStatement, \
+    _EXPRESSIONS, add, add_job, color, flush_tasks, indent, statement, relative_path
+from esphomeyaml.util import safe_print, run_external_command
 
 _LOGGER = logging.getLogger(__name__)
 
-PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'i2c']
-
-CONFIG_PATH = None
+PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'web_server', 'i2c']
 
 
-def get_name(config):
-    return config[CONF_ESPHOMEYAML][CONF_NAME]
-
-
-def get_base_path(config):
-    return os.path.join(os.path.dirname(CONFIG_PATH), get_name(config))
-
-
-def discover_serial_ports():
+def get_serial_ports():
     # from https://github.com/pyserial/pyserial/blob/master/serial/tools/list_ports.py
-    try:
-        from serial.tools.list_ports import comports
-    except ImportError:
-        return None
-
-    result = None
-    for p, d, h in comports():
-        if not p:
+    from serial.tools.list_ports import comports
+    result = []
+    for port, desc, info in comports():
+        if not port:
             continue
-        if "VID:PID" in h:
-            if result is not None:
-                return None
-            result = p
-
+        if "VID:PID" in info:
+            result.append((port, desc))
     return result
 
 
-def run_platformio(*cmd):
-    def mock_exit(rc):
-        raise SystemExit(rc)
+def choose_serial_port(config):
+    result = get_serial_ports()
 
-    orig_argv = sys.argv
-    orig_exit = sys.exit  # mock sys.exit
-    full_cmd = u' '.join(quote(x) for x in cmd)
-    _LOGGER.info(u"Running:  %s", full_cmd)
-    try:
-        import platformio.__main__
-        sys.argv = list(cmd)
-        sys.exit = mock_exit
-        return platformio.__main__.main()
-    except KeyboardInterrupt:
-        return 1
-    except SystemExit as e:
-        return e.args[0]
-    except Exception as e:
-        _LOGGER.error(u"Running platformio failed: %s", e)
-        _LOGGER.error(u"Please try running %s locally.", full_cmd)
-    finally:
-        sys.argv = orig_argv
-        sys.exit = orig_exit
+    if not result:
+        return 'OTA'
+    safe_print(u"Found multiple serial port options, please choose one:")
+    for i, (res, desc) in enumerate(result):
+        safe_print(u"  [{}] {} ({})".format(i, res, desc))
+    safe_print(u"  [{}] Over The Air ({})".format(len(result), get_upload_host(config)))
+    safe_print()
+    while True:
+        opt = raw_input('(number): ')
+        if opt in result:
+            opt = result.index(opt)
+            break
+        try:
+            opt = int(opt)
+            if opt < 0 or opt > len(result):
+                raise ValueError
+            break
+        except ValueError:
+            safe_print(color('red', u"Invalid option: '{}'".format(opt)))
+    if opt == len(result):
+        return 'OTA'
+    return result[opt][0]
 
 
-def run_miniterm(config, port):
-    from serial.tools import miniterm
-    baud_rate = config.get(CONF_LOGGER, {}).get(CONF_BAUD_RATE, 115200)
-    sys.argv = ['miniterm', '--raw', '--exit-char', '3']
-    miniterm.main(
-        default_port=port,
-        default_baudrate=baud_rate)
+def run_miniterm(config, port, escape=False):
+    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
+            line = raw.replace('\r', '').replace('\n', '')
+            time = datetime.now().time().strftime('[%H:%M:%S]')
+            message = time + line
+            if escape:
+                message = message.replace('\033', '\\033')
+            safe_print(message)
+
+            backtrace_state = platformio_api.process_stacktrace(
+                config, line, backtrace_state=backtrace_state)
 
 
 def write_cpp(config):
     _LOGGER.info("Generating C++ source...")
+
+    add_job(core_config.to_code, config[CONF_ESPHOMEYAML], domain='esphomeyaml')
     for domain in PRE_INITIALIZE:
-        if domain in config:
-            add_component_task(domain, config[domain])
-
-    # Clear queue
-    get_variable(None)
-    add(RawStatement(''))
-
-    for domain, conf in config.iteritems():
-        if domain in PRE_INITIALIZE:
+        if domain == CONF_ESPHOMEYAML or domain not in config:
             continue
-        add_component_task(domain, conf)
+        add_job(get_component(domain).to_code, config[domain], domain=domain)
 
-    # Clear queue
-    get_variable(None)
+    for domain, component, conf in iter_components(config):
+        if domain in PRE_INITIALIZE or not hasattr(component, 'to_code'):
+            continue
+        add_job(component.to_code, conf, domain=domain)
+
+    flush_tasks()
     add(RawStatement(''))
     add(RawStatement(''))
-
     all_code = []
     for exp in _EXPRESSIONS:
-        if helpers.SIMPLIFY and isinstance(exp, AssignmentExpression) and exp.obj.usages == 0:
-            exp = exp.rhs
+        if not config[CONF_ESPHOMEYAML][CONF_USE_CUSTOM_CODE]:
+            if isinstance(exp, Expression) and not exp.required:
+                continue
+            if isinstance(exp, AssignmentExpression) and not exp.obj.required:
+                if not exp.has_side_effects():
+                    continue
+                exp = exp.rhs
         all_code.append(unicode(statement(exp)))
 
-    platformio_ini_s = writer.get_ini_content(config)
-    ini_path = os.path.join(get_base_path(config), 'platformio.ini')
-    writer.write_platformio_ini(platformio_ini_s, ini_path)
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    writer.write_platformio_project(config, build_path)
 
-    code_s = indent('\n'.join(all_code))
-    cpp_path = os.path.join(get_base_path(config), 'src', 'main.cpp')
+    code_s = indent('\n'.join(line.rstrip() for line in all_code))
+    cpp_path = os.path.join(build_path, 'src', 'main.cpp')
     writer.write_cpp(code_s, cpp_path)
     return 0
 
 
-def compile_program(config):
+def compile_program(args, config):
     _LOGGER.info("Compiling app...")
-    return run_platformio('platformio', 'run', '-d', get_base_path(config))
+    return platformio_api.run_compile(config, args.verbose)
 
 
-def upload_program(config, args, port):
-    _LOGGER.info("Uploading binary...")
-    if args.upload_port is not None:
-        if args.upload_port == 'HELLO':
-            return run_platformio('platformio', 'run', '-d', get_base_path(config),
-                                  '-t', 'upload')
-        else:
-            return run_platformio('platformio', 'run', '-d', get_base_path(config),
-                                  '-t', 'upload', '--upload-port', args.upload_port)
-
-    if port is not None:
-        _LOGGER.info("Serial device discovered, using it for upload")
-        return run_platformio('platformio', 'run', '-d', get_base_path(config),
-                              '-t', 'upload', '--upload-port', port)
-
+def get_upload_host(config):
     if CONF_MANUAL_IP in config[CONF_WIFI]:
         host = str(config[CONF_WIFI][CONF_MANUAL_IP][CONF_STATIC_IP])
     elif CONF_HOSTNAME in config[CONF_WIFI]:
-        host = config[CONF_WIFI][CONF_HOSTNAME] + u'.local'
+        host = config[CONF_WIFI][CONF_HOSTNAME] + config[CONF_WIFI][CONF_DOMAIN]
     else:
-        host = config[CONF_ESPHOMEYAML][CONF_NAME] + u'.local'
+        host = config[CONF_ESPHOMEYAML][CONF_NAME] + config[CONF_WIFI][CONF_DOMAIN]
+    return host
+
+
+def upload_using_esptool(config, port):
+    import esptool
+
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    path = os.path.join(build_path, '.pioenvs', core.NAME, 'firmware.bin')
+    cmd = ['esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
+           '--chip', 'esp8266', '--port', port, 'write_flash', '0x0', path]
+    # pylint: disable=protected-access
+    return run_external_command(esptool._main, *cmd)
+
+
+def upload_program(config, args, port):
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+
+    # if upload is to a serial port use platformio, otherwise assume ota
+    serial_port = port.startswith('/') or port.startswith('COM')
+    if port != 'OTA' and serial_port:
+        if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266 and args.use_esptoolpy:
+            return upload_using_esptool(config, port)
+        return platformio_api.run_upload(config, args.verbose, port)
+
+    if 'ota' not in config:
+        _LOGGER.error("No serial port found and OTA not enabled. Can't upload!")
+        return -1
+
+    # If hostname/ip is explicitly provided as upload-port argument, use this instead of zeroconf
+    # hostname. This is to support use cases where zeroconf (hostname.local) does not work.
+    if port != 'OTA':
+        host = port
+    else:
+        host = get_upload_host(config)
 
     from esphomeyaml.components import ota
-    from esphomeyaml import espota
+    from esphomeyaml import espota2
 
-    bin_file = os.path.join(get_base_path(config), '.pioenvs', get_name(config), 'firmware.bin')
+    bin_file = os.path.join(build_path, '.pioenvs', core.NAME, 'firmware.bin')
     if args.host_port is not None:
         host_port = args.host_port
     else:
         host_port = int(os.getenv('ESPHOMEYAML_OTA_HOST_PORT', random.randint(10000, 60000)))
-    espota_args = ['espota.py', '--debug', '--progress', '-i', host,
-                   '-p', str(ota.get_port(config)), '-f', bin_file,
-                   '-a', ota.get_auth(config), '-P', str(host_port)]
-    return espota.main(espota_args)
+
+    verbose = args.verbose
+    remote_port = ota.get_port(config)
+    password = ota.get_auth(config)
+
+    res = espota2.run_ota(host, remote_port, password, bin_file)
+    if res == 0:
+        return res
+    _LOGGER.warn("OTA v2 method failed. Trying with legacy OTA...")
+    return espota2.run_legacy_ota(verbose, host_port, host, remote_port, password, bin_file)
 
 
-def show_logs(config, args, port):
-    if port is not None:
-        run_miniterm(config, port)
+def show_logs(config, args, port, escape=False):
+    serial_port = port.startswith('/') or port.startswith('COM')
+    if port != 'OTA' and serial_port:
+        run_miniterm(config, port, escape=escape)
         return 0
-    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id,
+                          escape=escape)
 
 
 def clean_mqtt(config, args):
     return mqtt.clear_topic(config, args.topic, args.username, args.password, args.client_id)
 
 
-def setup_log():
-    logging.basicConfig(level=logging.INFO)
-    fmt = "%(levelname)s [%(name)s] %(message)s"
+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'
 
@@ -196,27 +235,177 @@ def setup_log():
         pass
 
 
-def main():
-    global CONFIG_PATH
+def command_wizard(args):
+    return wizard.wizard(args.configuration)
 
-    setup_log()
 
+def strip_default_ids(config):
+    value = config
+    if isinstance(config, list):
+        value = type(config)()
+        for x in config:
+            if isinstance(x, core.ID) and not x.is_manual:
+                continue
+            value.append(strip_default_ids(x))
+        return value
+    elif isinstance(config, dict):
+        value = type(config)()
+        for k, v in config.iteritems():
+            if isinstance(v, core.ID) and not v.is_manual:
+                continue
+            value[k] = strip_default_ids(v)
+        return value
+    return value
+
+
+def command_config(args, config):
+    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 = args.upload_port or choose_serial_port(config)
+    exit_code = upload_program(config, args, port)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully uploaded program.")
+    return 0
+
+
+def command_logs(args, config):
+    port = args.serial_port or choose_serial_port(config)
+    return show_logs(config, args, port, escape=args.escape)
+
+
+def command_run(args, config):
+    exit_code = write_cpp(config)
+    if exit_code != 0:
+        return exit_code
+    exit_code = compile_program(args, config)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully compiled program.")
+    port = args.upload_port or choose_serial_port(config)
+    exit_code = upload_program(config, args, port)
+    if exit_code != 0:
+        return exit_code
+    _LOGGER.info(u"Successfully uploaded program.")
+    if args.no_logs:
+        return 0
+    return show_logs(config, args, port, escape=args.escape)
+
+
+def command_clean_mqtt(args, config):
+    return clean_mqtt(config, args)
+
+
+def command_mqtt_fingerprint(args, config):
+    return mqtt.get_fingerprint(config)
+
+
+def command_version(args):
+    safe_print(u"Version: {}".format(const.__version__))
+    return 0
+
+
+def command_clean(args, config):
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    try:
+        writer.clean_build(build_path)
+    except OSError as err:
+        _LOGGER.error("Error deleting build files: %s", err)
+        return 1
+    _LOGGER.info("Done!")
+    return 0
+
+
+def command_hass_config(args, config):
+    from esphomeyaml.components import mqtt as mqtt_component
+
+    _LOGGER.info("This is what you should put in your Home Assistant YAML configuration.")
+    _LOGGER.info("Please note this is only necessary if you're not using MQTT discovery.")
+    data = mqtt_component.GenerateHassConfigData(config)
+    hass_config = OrderedDict()
+    for domain, component, conf in iter_components(config):
+        if not hasattr(component, 'to_hass_config'):
+            continue
+        func = getattr(component, 'to_hass_config')
+        ret = func(data, conf)
+        if not isinstance(ret, (list, tuple)):
+            ret = [ret]
+        ret = [x for x in ret if x is not None]
+        domain_conf = hass_config.setdefault(domain.split('.')[0], [])
+        domain_conf += ret
+
+    safe_print(yaml_util.dump(hass_config))
+    return 0
+
+
+def command_dashboard(args):
+    from esphomeyaml.dashboard import dashboard
+
+    return dashboard.start_web_server(args)
+
+
+PRE_CONFIG_ACTIONS = {
+    'wizard': command_wizard,
+    'version': command_version,
+    'dashboard': command_dashboard
+}
+
+POST_CONFIG_ACTIONS = {
+    'config': command_config,
+    'compile': command_compile,
+    'upload': command_upload,
+    'logs': command_logs,
+    'run': command_run,
+    'clean-mqtt': command_clean_mqtt,
+    'mqtt-fingerprint': command_mqtt_fingerprint,
+    'clean': command_clean,
+    'hass-config': command_hass_config,
+}
+
+
+def parse_args(argv):
     parser = argparse.ArgumentParser(prog='esphomeyaml')
+    parser.add_argument('-v', '--verbose', help="Enable verbose esphomeyaml logs.",
+                        action='store_true')
     parser.add_argument('configuration', help='Your YAML configuration file.')
+
     subparsers = parser.add_subparsers(help='Commands', dest='command')
     subparsers.required = True
-    parser_config = subparsers.add_parser('config',
-                                          help='Validate the configuration and spit it out.')
+    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_USBtoUAR.",
-                               nargs='?', const='HELLO')
+                                                     "For example /dev/cu.SLAB_USBtoUART.")
     parser_upload.add_argument('--host-port', help="Specify the host port.", type=int)
+    parser_upload.add_argument('--use-esptoolpy',
+                               help="Use esptool.py for the uploading (only for ESP8266)",
+                               action='store_true')
 
     parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
                                                      'and show all MQTT logs.')
@@ -224,12 +413,15 @@ def main():
     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_logs.add_argument('--escape', help="Escape ANSI color codes for running in dashboard",
+                             action='store_true')
 
     parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
                                                    'upload it, and start MQTT logs.')
-    parser_run.add_argument('--upload-port', help="Manually specify the upload port to use. "
-                                                  "For example /dev/cu.SLAB_USBtoUAR.",
-                            nargs='?', const='HELLO')
+    parser_run.add_argument('--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')
@@ -237,6 +429,11 @@ def main():
     parser_run.add_argument('--username', help='Manually set the MQTT username for logs.')
     parser_run.add_argument('--password', help='Manually set the MQTT password for logs.')
     parser_run.add_argument('--client-id', help='Manually set the client id for logs.')
+    parser_run.add_argument('--escape', help="Escape ANSI color codes for running in dashboard",
+                            action='store_true')
+    parser_run.add_argument('--use-esptoolpy',
+                            help="Use esptool.py for the uploading (only for ESP8266)",
+                            action='store_true')
 
     parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
                                                             "retain messages.")
@@ -245,60 +442,63 @@ def main():
     parser_clean.add_argument('--password', help='Manually set the password.')
     parser_clean.add_argument('--client-id', help='Manually set the client id.')
 
-    parser_wizard = subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
-                                                         "you through setting up esphomeyaml.")
+    subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
+                                         "you through setting up esphomeyaml.")
 
-    args = parser.parse_args()
+    subparsers.add_parser('mqtt-fingerprint', help="Get the SSL fingerprint from a MQTT broker.")
 
-    if args.command == 'wizard':
-        return wizard.wizard(args.configuration)
+    subparsers.add_parser('version', help="Print the esphomeyaml version and exit.")
 
-    CONFIG_PATH = args.configuration
-    config = read_config(CONFIG_PATH)
+    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.", 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')
+
+    subparsers.add_parser('hass-config', help="Dump the configuration entries that should be added"
+                                              "to Home Assistant when not using MQTT discovery.")
+
+    return parser.parse_args(argv[1:])
+
+
+def run_esphomeyaml(argv):
+    args = parse_args(argv)
+    setup_log(args.verbose)
+    if args.command in PRE_CONFIG_ACTIONS:
+        try:
+            return PRE_CONFIG_ACTIONS[args.command](args)
+        except ESPHomeYAMLError as e:
+            _LOGGER.error(e)
+            return 1
+
+    core.CONFIG_PATH = args.configuration
+
+    config = read_config(core.CONFIG_PATH)
     if config is None:
         return 1
 
-    if args.command == 'config':
-        print(yaml_util.dump(config))
-    elif args.command == 'compile':
-        exit_code = write_cpp(config)
-        if exit_code != 0:
-            return exit_code
-        exit_code = compile_program(config)
-        if exit_code != 0:
-            return exit_code
-        _LOGGER.info(u"Successfully compiled program.")
-        return 0
-    elif args.command == 'upload':
-        port = discover_serial_ports()
-        exit_code = upload_program(config, args, port)
-        if exit_code != 0:
-            return exit_code
-        _LOGGER.info(u"Successfully uploaded program.")
-        return 0
-    elif args.command == 'logs':
-        port = discover_serial_ports()
-        return show_logs(config, args, port)
-    elif args.command == 'clean-mqtt':
-        return clean_mqtt(config, args)
-    elif args.command == 'run':
-        exit_code = write_cpp(config)
-        if exit_code != 0:
-            return exit_code
-        exit_code = compile_program(config)
-        if exit_code != 0:
-            return exit_code
-        _LOGGER.info(u"Successfully compiled program.")
-        if args.no_logs:
-            return
-        port = discover_serial_ports()
-        exit_code = upload_program(config, args, port)
-        if exit_code != 0:
-            return exit_code
-        _LOGGER.info(u"Successfully uploaded program.")
-        return show_logs(config, args, port)
-    else:
-        print(u"Unknown command {}".format(args.command))
+    if args.command in POST_CONFIG_ACTIONS:
+        try:
+            return POST_CONFIG_ACTIONS[args.command](args, config)
+        except ESPHomeYAMLError as e:
+            _LOGGER.error(e)
+            return 1
+    safe_print(u"Unknown command {}".format(args.command))
+    return 1
+
+
+def main():
+    try:
+        return run_esphomeyaml(sys.argv)
+    except ESPHomeYAMLError as e:
+        _LOGGER.error(e)
+        return 1
+    except KeyboardInterrupt:
         return 1
 
 

esphomeyaml/automation.py

@@ -0,0 +1,283 @@
+import copy
+
+import voluptuous as vol
+
+from esphomeyaml import core
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, TemplateArguments, add, add_job, \
+    esphomelib_ns, float_, process_lambda, templatable, uint32, get_variable, PollingComponent, \
+    Action, Component, Trigger
+from esphomeyaml.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):
+    return CONDITIONS_SCHEMA(value)
+
+
+def validate_recursive_action(value):
+    value = cv.ensure_list(value)[:]
+    for i, item in enumerate(value):
+        item = copy.deepcopy(item)
+        if not isinstance(item, dict):
+            raise vol.Invalid(u"Action must consist of key-value mapping! Got {}".format(item))
+        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))
+        if key not in ACTION_REGISTRY:
+            raise vol.Invalid(u"Unable to find action with the name '{}', is the component loaded?"
+                              u"".format(key))
+        item.setdefault(CONF_ACTION_ID, None)
+        key2 = next((x for x in item if x != CONF_ACTION_ID and x != 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 action?"
+                              u"".format(key, key2))
+        validator = ACTION_REGISTRY[key][0]
+        value[i] = {
+            CONF_ACTION_ID: cv.declare_variable_id(Action)(item[CONF_ACTION_ID]),
+            key: validator(item[key])
+        }
+    return value
+
+
+ACTION_REGISTRY = ServiceRegistry()
+
+# pylint: disable=invalid-name
+DelayAction = esphomelib_ns.class_('DelayAction', Action, Component)
+LambdaAction = esphomelib_ns.class_('LambdaAction', Action)
+IfAction = esphomelib_ns.class_('IfAction', Action)
+UpdateComponentAction = esphomelib_ns.class_('UpdateComponentAction', Action)
+Automation = esphomelib_ns.class_('Automation')
+
+Condition = esphomelib_ns.class_('Condition')
+AndCondition = esphomelib_ns.class_('AndCondition', Condition)
+OrCondition = esphomelib_ns.class_('OrCondition', Condition)
+RangeCondition = esphomelib_ns.class_('RangeCondition', Condition)
+LambdaCondition = esphomelib_ns.class_('LambdaCondition', Condition)
+
+CONDITIONS_SCHEMA = vol.All(cv.ensure_list, [cv.templatable({
+    cv.GenerateID(CONF_CONDITION_ID): cv.declare_variable_id(Condition),
+    vol.Optional(CONF_AND): validate_recursive_condition,
+    vol.Optional(CONF_OR): validate_recursive_condition,
+    vol.Optional(CONF_RANGE): vol.All(vol.Schema({
+        vol.Optional(CONF_ABOVE): vol.Coerce(float),
+        vol.Optional(CONF_BELOW): vol.Coerce(float),
+    }), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+})])
+
+
+def validate_automation(extra_schema=None, extra_validators=None, single=False):
+    schema = AUTOMATION_SCHEMA.extend(extra_schema or {})
+
+    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:
+                # Next try as a sequence of automations
+                try:
+                    return vol.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 = vol.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 = vol.Schema({
+    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(Trigger),
+    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(Automation),
+    vol.Optional(CONF_IF): CONDITIONS_SCHEMA,
+    vol.Required(CONF_THEN): validate_recursive_action,
+})
+
+
+def build_condition(config, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    if isinstance(config, core.Lambda):
+        lambda_ = None
+        for lambda_ in process_lambda(config, [(arg_type, 'x')]):
+            yield
+        yield LambdaCondition.new(template_arg, lambda_)
+    elif CONF_AND in config:
+        yield AndCondition.new(template_arg, build_conditions(config[CONF_AND], template_arg))
+    elif CONF_OR in config:
+        yield OrCondition.new(template_arg, build_conditions(config[CONF_OR], template_arg))
+    elif CONF_LAMBDA in config:
+        lambda_ = None
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(arg_type, 'x')]):
+            yield
+        yield LambdaCondition.new(template_arg, lambda_)
+    elif CONF_RANGE in config:
+        conf = config[CONF_RANGE]
+        rhs = RangeCondition.new(template_arg)
+        type = RangeCondition.template(template_arg)
+        condition = Pvariable(config[CONF_CONDITION_ID], rhs, type=type)
+        if CONF_ABOVE in conf:
+            template_ = None
+            for template_ in templatable(conf[CONF_ABOVE], arg_type, float_):
+                yield
+            condition.set_min(template_)
+        if CONF_BELOW in conf:
+            template_ = None
+            for template_ in templatable(conf[CONF_BELOW], arg_type, float_):
+                yield
+            condition.set_max(template_)
+        yield condition
+    else:
+        raise ESPHomeYAMLError(u"Unsupported condition {}".format(config))
+
+
+def build_conditions(config, arg_type):
+    conditions = []
+    for conf in config:
+        condition = None
+        for condition in build_condition(conf, arg_type):
+            yield None
+        conditions.append(condition)
+    yield ArrayInitializer(*conditions)
+
+
+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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    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, arg_type, 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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for conditions in build_conditions(config[CONF_CONDITION], arg_type):
+        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], arg_type):
+            yield None
+        add(action.add_then(actions))
+    if CONF_ELSE in config:
+        for actions in build_actions(config[CONF_ELSE], arg_type):
+            yield None
+        add(action.add_else(actions))
+    yield action
+
+
+LAMBDA_ACTION_SCHEMA = cv.lambda_
+
+
+@ACTION_REGISTRY.register(CONF_LAMBDA, LAMBDA_ACTION_SCHEMA)
+def lambda_action_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for lambda_ in process_lambda(config, [(arg_type, 'x')]):
+        yield None
+    rhs = LambdaAction.new(template_arg, lambda_)
+    type = LambdaAction.template(template_arg)
+    yield Pvariable(action_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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = UpdateComponentAction.new(var)
+    type = UpdateComponentAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+def build_action(full_config, arg_type):
+    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, arg_type):
+        yield None
+    yield result
+
+
+def build_actions(config, arg_type):
+    actions = []
+    for conf in config:
+        action = None
+        for action in build_action(conf, arg_type):
+            yield None
+        actions.append(action)
+    yield ArrayInitializer(*actions, multiline=False)
+
+
+def build_automation_(trigger, arg_type, config):
+    rhs = App.make_automation(TemplateArguments(arg_type), trigger)
+    type = Automation.template(arg_type)
+    obj = Pvariable(config[CONF_AUTOMATION_ID], rhs, type=type)
+    if CONF_IF in config:
+        conditions = None
+        for conditions in build_conditions(config[CONF_IF], arg_type):
+            yield None
+        add(obj.add_conditions(conditions))
+    actions = None
+    for actions in build_actions(config[CONF_THEN], arg_type):
+        yield None
+    add(obj.add_actions(actions))
+    yield obj
+
+
+def build_automation(trigger, arg_type, config):
+    add_job(build_automation_, trigger, arg_type, config)

esphomeyaml/components/ads1115.py

@@ -1,37 +1,27 @@
 import voluptuous as vol
 
+from esphomeyaml.components import sensor, i2c
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_RATE
-from esphomeyaml.helpers import App, Pvariable, RawExpression, add, HexIntLiteral
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID
+from esphomeyaml.helpers import App, Pvariable, setup_component, Component
 
 DEPENDENCIES = ['i2c']
 
-ADS1115_COMPONENT_CLASS = 'sensor::ADS1115Component'
-
-RATES = {
-    8: 'ADS1115_RATE_8',
-    16: 'ADS1115_RATE_16',
-    32: 'ADS1115_RATE_32',
-    64: 'ADS1115_RATE_64',
-    128: 'ADS1115_RATE_128',
-    250: 'ADS1115_RATE_250',
-    475: 'ADS1115_RATE_475',
-    860: 'ADS1115_RATE_860',
-}
+ADS1115Component = sensor.sensor_ns.class_('ADS1115Component', Component, i2c.I2CDevice)
 
 ADS1115_SCHEMA = vol.Schema({
-    cv.GenerateID('ads1115'): cv.register_variable_id,
+    cv.GenerateID(): cv.declare_variable_id(ADS1115Component),
     vol.Required(CONF_ADDRESS): cv.i2c_address,
-    vol.Optional(CONF_RATE): vol.All(vol.Coerce(int), vol.Any(*list(RATES.keys()))),
-})
+}).extend(cv.COMPONENT_SCHEMA.schema)
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [ADS1115_SCHEMA])
 
 
 def to_code(config):
     for conf in config:
-        address = HexIntLiteral(conf[CONF_ADDRESS])
-        rhs = App.make_ads1115_component(address)
-        ads1115 = Pvariable(ADS1115_COMPONENT_CLASS, conf[CONF_ID], rhs)
-        if CONF_RATE in conf:
-            add(ads1115.set_rate(RawExpression(RATES[conf[CONF_RATE]])))
+        rhs = App.make_ads1115_component(conf[CONF_ADDRESS])
+        var = Pvariable(conf[CONF_ID], rhs)
+        setup_component(var, conf)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphomeyaml/components/binary_sensor/__init__.py

@@ -1,12 +1,16 @@
 import voluptuous as vol
 
+from esphomeyaml import automation, core
+from esphomeyaml.components import mqtt
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_INVERTED
-from esphomeyaml.helpers import add, setup_mqtt_component
-
-PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_INVERTED): cv.boolean,
-})
+from esphomeyaml.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_STATE, \
+    CONF_TIMING, CONF_TRIGGER_ID
+from esphomeyaml.helpers import App, ArrayInitializer, NoArg, Pvariable, StructInitializer, add, \
+    add_job, bool_, esphomelib_ns, process_lambda, setup_mqtt_component, Nameable, Trigger, \
+    Component
 
 DEVICE_CLASSES = [
     '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
@@ -15,15 +19,274 @@ DEVICE_CLASSES = [
     'sound', 'vibration', 'window'
 ]
 
-DEVICE_CLASSES_MSG = "Unknown device class. Must be one of {}".format(', '.join(DEVICE_CLASSES))
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
-MQTT_BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
-    vol.Optional(CONF_DEVICE_CLASS): vol.All(vol.Lower,
-                                             vol.Any(*DEVICE_CLASSES, msg=DEVICE_CLASSES_MSG)),
+})
+
+binary_sensor_ns = esphomelib_ns.namespace('binary_sensor')
+BinarySensor = binary_sensor_ns.class_('BinarySensor', Nameable)
+MQTTBinarySensorComponent = binary_sensor_ns.class_('MQTTBinarySensorComponent', mqtt.MQTTComponent)
+
+# Triggers
+PressTrigger = binary_sensor_ns.class_('PressTrigger', Trigger.template(NoArg))
+ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', Trigger.template(NoArg))
+ClickTrigger = binary_sensor_ns.class_('ClickTrigger', Trigger.template(NoArg))
+DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', Trigger.template(NoArg))
+MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', Trigger.template(NoArg), Component)
+MultiClickTriggerEvent = binary_sensor_ns.struct('MultiClickTriggerEvent')
+
+# 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 = vol.All(cv.ensure_list, [vol.All({
+    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_HEARTBEAT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+}, cv.has_exactly_one_key(*FILTER_KEYS))])
+
+MULTI_CLICK_TIMING_SCHEMA = vol.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 setup_mqtt_binary_sensor(obj, config, skip_device_class=False):
-    if not skip_device_class and CONF_DEVICE_CLASS in config:
-        add(obj.set_device_class(config[CONF_DEVICE_CLASS]))
-    setup_mqtt_component(obj, config)
+def parse_multi_click_timing_str(value):
+    if not isinstance(value, basestring):
+        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): vol.All(vol.Lower, cv.one_of(*DEVICE_CLASSES)),
+    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_INVERTED): cv.invalid(
+        "The inverted binary_sensor property has been replaced by the "
+        "new 'invert' binary  sensor filter. Please see "
+        "https://esphomelib.com/esphomeyaml/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_HEARTBEAT in config:
+        yield App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
+    elif CONF_LAMBDA in config:
+        lambda_ = None
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(bool_, 'x')]):
+            yield None
+        yield LambdaFilter.new(lambda_)
+
+
+def setup_filters(config):
+    filters = []
+    for conf in config:
+        filter = None
+        for filter in setup_filter(conf):
+            yield None
+        filters.append(filter)
+    yield ArrayInitializer(*filters)
+
+
+def setup_binary_sensor_core_(binary_sensor_var, mqtt_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:
+        filters = None
+        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_automation(trigger, NoArg, 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_automation(trigger, NoArg, conf)
+
+    for conf in config.get(CONF_ON_CLICK, []):
+        rhs = binary_sensor_var.make_click_trigger(conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH])
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, conf)
+
+    for conf in config.get(CONF_ON_DOUBLE_CLICK, []):
+        rhs = binary_sensor_var.make_double_click_trigger(conf[CONF_MIN_LENGTH],
+                                                          conf[CONF_MAX_LENGTH])
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, 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)),
+            ))
+        timings = ArrayInitializer(*timings, multiline=False)
+        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_automation(trigger, NoArg, conf)
+
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_binary_sensor(binary_sensor_obj, mqtt_obj, config):
+    binary_sensor_var = Pvariable(config[CONF_ID], binary_sensor_obj,
+                                  has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj,
+                         has_side_effects=False)
+    add_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_var, config)
+
+
+def register_binary_sensor(var, config):
+    binary_sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    rhs = App.register_binary_sensor(binary_sensor_var)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], rhs, has_side_effects=True)
+    add_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_var, config)
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'binary_sensor', config,
+                                 include_state=True, include_command=False)
+    if ret is None:
+        return None
+    if CONF_DEVICE_CLASS in config:
+        ret['device_class'] = config[CONF_DEVICE_CLASS]
+    return ret
+
+
+BUILD_FLAGS = '-DUSE_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/esp32_ble_tracker.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphomeyaml.helpers import esphomelib_ns, get_variable
+
+DEPENDENCIES = ['esp32_ble_tracker']
+ESP32BLEPresenceDevice = esphomelib_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):
+    hub = None
+    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)
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/esp32_touch.py

@@ -0,0 +1,61 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.esp32_touch import ESP32TouchComponent
+from esphomeyaml.const import CONF_NAME, CONF_PIN, CONF_THRESHOLD, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import get_variable, global_ns
+from esphomeyaml.pins import validate_gpio_pin
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+DEPENDENCIES = ['esp32_touch']
+
+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'
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/gpio.py

@@ -3,19 +3,34 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import binary_sensor
-from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_ID, CONF_INVERTED, CONF_NAME, CONF_PIN
-from esphomeyaml.helpers import App, add, exp_gpio_input_pin, variable
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, gpio_input_pin_expression, variable, Application, \
+    setup_component, Component
 
-PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('gpio_binary_sensor'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.GPIO_INPUT_PIN_SCHEMA
-}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+MakeGPIOBinarySensor = Application.struct('MakeGPIOBinarySensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeGPIOBinarySensor),
+    vol.Required(CONF_PIN): pins.gpio_input_pin_schema
+}).extend(cv.COMPONENT_SCHEMA.schema))
 
 
 def to_code(config):
-    rhs = App.make_gpio_binary_sensor(exp_gpio_input_pin(config[CONF_PIN]),
-                                      config[CONF_NAME], config.get(CONF_DEVICE_CLASS))
-    gpio = variable('Application::SimpleBinarySensor', config[CONF_ID], rhs)
-    if CONF_INVERTED in config:
-        add(gpio.Pgpio.set_inverted(config[CONF_INVERTED]))
-    binary_sensor.setup_mqtt_binary_sensor(gpio.Pmqtt, config, skip_device_class=True)
+    pin = None
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_gpio_binary_sensor(config[CONF_NAME], pin)
+    gpio = variable(config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(gpio.Pgpio, gpio.Pmqtt, config)
+    setup_component(gpio.Pgpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_BINARY_SENSOR'
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/nextion.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphomeyaml.components import binary_sensor, display
+from esphomeyaml.components.display.nextion import Nextion
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_COMPONENT_ID, CONF_NAME, CONF_PAGE_ID
+from esphomeyaml.helpers 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):
+    hub = None
+    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)
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/pn532.py

@@ -0,0 +1,49 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.pn532 import PN532Component
+from esphomeyaml.const import CONF_NAME, CONF_UID
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import ArrayInitializer, 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], ArrayInitializer(*addr, multiline=False))
+    binary_sensor.register_binary_sensor(rhs, config)
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/rdm6300.py

@@ -0,0 +1,30 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor, rdm6300
+from esphomeyaml.const import CONF_NAME, CONF_UID
+from esphomeyaml.helpers 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)
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/remote_receiver.py

@@ -0,0 +1,125 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.remote_receiver import RemoteReceiverComponent, remote_ns
+from esphomeyaml.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
+from esphomeyaml.const import CONF_ADDRESS, CONF_CHANNEL, CONF_CODE, CONF_COMMAND, CONF_DATA, \
+    CONF_DEVICE, CONF_FAMILY, CONF_GROUP, 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
+from esphomeyaml.helpers import ArrayInitializer, Pvariable, get_variable
+
+DEPENDENCIES = ['remote_receiver']
+
+REMOTE_KEYS = [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_REMOTE_RECEIVER_ID = 'remote_receiver_id'
+CONF_RECEIVER_ID = 'receiver_id'
+
+RemoteReceiver = remote_ns.class_('RemoteReceiver', binary_sensor.BinarySensor)
+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)
+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)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RemoteReceiver),
+    vol.Optional(CONF_LG): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), cv.one_of(28, 32)),
+    }),
+    vol.Optional(CONF_NEC): vol.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint16_t,
+    }),
+    vol.Optional(CONF_SAMSUNG): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_SONY): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), cv.one_of(12, 15, 20)),
+    }),
+    vol.Optional(CONF_PANASONIC): vol.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_RAW): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
+    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_LG:
+        return LGReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
+    elif key == CONF_NEC:
+        return NECReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    elif key == CONF_PANASONIC:
+        return PanasonicReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    elif key == CONF_SAMSUNG:
+        return SamsungReceiver.new(name, config[CONF_DATA])
+    elif key == CONF_SONY:
+        return SonyReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
+    elif key == CONF_RAW:
+        data = ArrayInitializer(*config, multiline=False)
+        return RawReceiver.new(name, data)
+    elif 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]))
+    elif 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])
+    elif 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])
+    elif 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])
+    elif 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])
+    else:
+        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'
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/status.py

@@ -1,14 +1,30 @@
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import binary_sensor
-from esphomeyaml.const import CONF_ID, CONF_NAME
-from esphomeyaml.helpers import App, Pvariable
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable, setup_component, Component
 
-PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('status_binary_sensor'): cv.register_variable_id,
-}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+DEPENDENCIES = ['mqtt']
+
+MakeStatusBinarySensor = Application.struct('MakeStatusBinarySensor')
+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(CONF_MAKE_ID): cv.declare_variable_id(MakeStatusBinarySensor),
+    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])
-    gpio = Pvariable('binary_sensor::MQTTBinarySensorComponent', config[CONF_ID], rhs)
-    binary_sensor.setup_mqtt_binary_sensor(gpio.Pmqtt, config)
+    status = variable(config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(status.Pstatus, status.Pmqtt, config)
+    setup_component(status.Pstatus, config)
+
+
+BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/template.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphomeyaml.components import binary_sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, add, bool_, optional, process_lambda, variable, \
+    setup_component, Component
+
+MakeTemplateBinarySensor = Application.struct('MakeTemplateBinarySensor')
+TemplateBinarySensor = binary_sensor.binary_sensor_ns.class_('TemplateBinarySensor',
+                                                             binary_sensor.BinarySensor,
+                                                             Component)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateBinarySensor),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateBinarySensor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_binary_sensor(config[CONF_NAME])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(make.Ptemplate_, make.Pmqtt, config)
+    setup_component(make.Ptemplate_, config)
+
+    template_ = None
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=optional.template(bool_)):
+        yield
+    add(make.Ptemplate_.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_BINARY_SENSOR'
+
+
+def to_hass_config(data, config):
+    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/cover/__init__.py

@@ -0,0 +1,102 @@
+import voluptuous as vol
+
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
+from esphomeyaml.components import mqtt
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_MQTT_ID, CONF_INTERNAL
+from esphomeyaml.helpers import Pvariable, esphomelib_ns, setup_mqtt_component, add, \
+    TemplateArguments, get_variable, Action, Nameable
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+cover_ns = esphomelib_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
+
+# 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, mqtt_var, config):
+    if CONF_INTERNAL in config:
+        add(cover_var.set_internal(config[CONF_INTERNAL]))
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_cover(cover_obj, mqtt_obj, config):
+    cover_var = Pvariable(config[CONF_ID], cover_obj, has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    setup_cover_core_(cover_var, mqtt_var, 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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_open_action(template_arg)
+    type = OpenAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_close_action(template_arg)
+    type = CloseAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_stop_action(template_arg)
+    type = StopAction.template(arg_type)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'cover', config, include_state=True, include_command=True)
+    if ret is None:
+        return None
+    return ret

esphomeyaml/components/cover/template.py

@@ -0,0 +1,59 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import automation
+from esphomeyaml.components import cover
+from esphomeyaml.const import CONF_CLOSE_ACTION, CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, \
+    CONF_OPEN_ACTION, CONF_STOP_ACTION, CONF_OPTIMISTIC
+from esphomeyaml.helpers import App, Application, NoArg, add, process_lambda, variable, optional, \
+    setup_component
+
+MakeTemplateCover = Application.struct('MakeTemplateCover')
+TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover)
+
+PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateCover),
+    cv.GenerateID(): cv.declare_variable_id(TemplateCover),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): 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), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
+
+
+def to_code(config):
+    rhs = App.make_template_cover(config[CONF_NAME])
+    make = variable(config[CONF_MAKE_ID], rhs)
+
+    cover.setup_cover(make.Ptemplate_, make.Pmqtt, config)
+    setup_component(make.Ptemplate_, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(cover.CoverState)):
+            yield
+        add(make.Ptemplate_.set_state_lambda(template_))
+    if CONF_OPEN_ACTION in config:
+        automation.build_automation(make.Ptemplate_.get_open_trigger(), NoArg,
+                                    config[CONF_OPEN_ACTION])
+    if CONF_CLOSE_ACTION in config:
+        automation.build_automation(make.Ptemplate_.get_close_trigger(), NoArg,
+                                    config[CONF_CLOSE_ACTION])
+    if CONF_STOP_ACTION in config:
+        automation.build_automation(make.Ptemplate_.get_stop_trigger(), NoArg,
+                                    config[CONF_STOP_ACTION])
+    if CONF_OPTIMISTIC in config:
+        add(make.Ptemplate_.set_optimistic(config[CONF_OPTIMISTIC]))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_COVER'
+
+
+def to_hass_config(data, config):
+    ret = cover.core_to_hass_config(data, config)
+    if ret is None:
+        return None
+    if CONF_OPTIMISTIC in config:
+        ret['optimistic'] = config[CONF_OPTIMISTIC]
+    return ret

esphomeyaml/components/dallas.py

@@ -2,19 +2,24 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
+from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Pvariable
+from esphomeyaml.helpers import App, Pvariable, setup_component, PollingComponent
 
-DALLAS_COMPONENT_CLASS = 'sensor::DallasComponent'
+DallasComponent = sensor.sensor_ns.class_('DallasComponent', PollingComponent)
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
-    cv.GenerateID('dallas'): cv.register_variable_id,
+    cv.GenerateID(): cv.declare_variable_id(DallasComponent),
     vol.Required(CONF_PIN): pins.input_output_pin,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-})])
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)])
 
 
 def to_code(config):
     for conf in config:
         rhs = App.make_dallas_component(conf[CONF_PIN], conf.get(CONF_UPDATE_INTERVAL))
-        Pvariable(DALLAS_COMPONENT_CLASS, conf[CONF_ID], rhs)
+        var = Pvariable(conf[CONF_ID], rhs)
+        setup_component(var, conf)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphomeyaml/components/debug.py

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

esphomeyaml/components/deep_sleep.py

@@ -0,0 +1,120 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv, pins
+from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_RUN_CYCLES, CONF_RUN_DURATION, \
+    CONF_SLEEP_DURATION, CONF_WAKEUP_PIN, CONF_MODE, CONF_PINS
+from esphomeyaml.helpers import Action, App, Component, Pvariable, TemplateArguments, add, \
+    esphomelib_ns, get_variable, gpio_input_pin_expression, setup_component, global_ns, \
+    StructInitializer
+
+
+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 = esphomelib_ns.class_('DeepSleepComponent', Component)
+EnterDeepSleepAction = esphomelib_ns.class_('EnterDeepSleepAction', Action)
+PreventDeepSleepAction = esphomelib_ns.class_('PreventDeepSleepAction', Action)
+
+WakeupPinMode = esphomelib_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 = esphomelib_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 = vol.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, vol.Upper,
+                                                cv.one_of(*WAKEUP_PIN_MODES)),
+    vol.Optional(CONF_ESP32_EXT1_WAKEUP): vol.All(cv.only_on_esp32, vol.Schema({
+        vol.Required(CONF_PINS): vol.All(cv.ensure_list, [pins.shorthand_input_pin],
+                                         [validate_pin_number]),
+        vol.Required(CONF_MODE): vol.All(vol.Upper, cv.one_of(*EXT1_WAKEUP_MODES)),
+    })),
+    vol.Optional(CONF_RUN_CYCLES): cv.positive_int,
+    vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
+}).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_CYCLES in config:
+        add(deep_sleep.set_run_cycles(config[CONF_RUN_CYCLES]))
+    if CONF_RUN_DURATION in config:
+        add(deep_sleep.set_run_duration(config[CONF_RUN_DURATION]))
+
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_enter_deep_sleep_action(template_arg)
+    type = EnterDeepSleepAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_prevent_deep_sleep_action(template_arg)
+    type = PreventDeepSleepAction.template(arg_type)
+    yield Pvariable(action_id, rhs, type=type)

esphomeyaml/components/display/__init__.py

@@ -0,0 +1,56 @@
+# coding=utf-8
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_LAMBDA, CONF_ROTATION, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import add, add_job, esphomelib_ns
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+display_ns = esphomelib_ns.namespace('display')
+DisplayBuffer = display_ns.class_('DisplayBuffer')
+DisplayBufferRef = DisplayBuffer.operator('ref')
+
+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,
+})
+
+
+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]]))
+
+
+def setup_display(display_var, config):
+    add_job(setup_display_core_, display_var, config)
+
+
+BUILD_FLAGS = '-DUSE_DISPLAY'

esphomeyaml/components/display/lcd_gpio.py

@@ -0,0 +1,74 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display
+from esphomeyaml.const import CONF_DATA_PINS, CONF_DIMENSIONS, CONF_ENABLE_PIN, CONF_ID, \
+    CONF_LAMBDA, CONF_RS_PIN, CONF_RW_PIN
+from esphomeyaml.helpers import App, Pvariable, add, gpio_output_pin_expression, process_lambda, \
+    setup_component, PollingComponent
+
+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')]):
+            yield
+        add(lcd.set_writer(lambda_))
+
+    display.setup_display(lcd, config)
+    setup_component(lcd, config)
+
+
+BUILD_FLAGS = '-DUSE_LCD_DISPLAY'

esphomeyaml/components/display/lcd_pcf8574.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import display, i2c
+from esphomeyaml.components.display.lcd_gpio import LCDDisplayRef, validate_lcd_dimensions, \
+    LCDDisplay
+from esphomeyaml.const import CONF_ADDRESS, CONF_DIMENSIONS, CONF_ID, CONF_LAMBDA
+from esphomeyaml.helpers import App, Pvariable, add, process_lambda, setup_component
+
+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')]):
+            yield
+        add(lcd.set_writer(lambda_))
+
+    display.setup_display(lcd, config)
+    setup_component(lcd, config)
+
+
+BUILD_FLAGS = ['-DUSE_LCD_DISPLAY', '-DUSE_LCD_DISPLAY_PCF8574']

esphomeyaml/components/display/max7219.py

@@ -0,0 +1,49 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display, spi
+from esphomeyaml.components.spi import SPIComponent
+from esphomeyaml.const import CONF_CS_PIN, CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, \
+    CONF_SPI_ID
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, gpio_output_pin_expression, \
+    process_lambda, setup_component, PollingComponent
+
+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')]):
+            yield
+        add(max7219.set_writer(lambda_))
+
+    display.setup_display(max7219, config)
+    setup_component(max7219, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX7219'

esphomeyaml/components/display/nextion.py

@@ -0,0 +1,35 @@
+from esphomeyaml.components import display, uart
+from esphomeyaml.components.uart import UARTComponent
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
+from esphomeyaml.helpers import App, PollingComponent, Pvariable, add, get_variable, \
+    process_lambda, \
+    setup_component
+
+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')]):
+            yield
+        add(nextion.set_writer(lambda_))
+
+    display.setup_display(nextion, config)
+    setup_component(nextion, config)
+
+
+BUILD_FLAGS = '-DUSE_NEXTION'

esphomeyaml/components/display/ssd1306_i2c.py

@@ -0,0 +1,47 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display
+from esphomeyaml.components.display import ssd1306_spi
+from esphomeyaml.const import CONF_ADDRESS, CONF_EXTERNAL_VCC, CONF_ID, \
+    CONF_MODEL, CONF_RESET_PIN, CONF_LAMBDA
+from esphomeyaml.helpers import App, Pvariable, add, \
+    gpio_output_pin_expression, process_lambda, setup_component
+
+DEPENDENCIES = ['i2c']
+
+I2CSSD1306 = display.display_ns.class_('I2CSSD1306', ssd1306_spi.SSD1306)
+
+PLATFORM_SCHEMA = 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)
+
+
+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')]):
+            yield
+        add(ssd.set_writer(lambda_))
+
+    display.setup_display(ssd, config)
+    setup_component(ssd, config)
+
+
+BUILD_FLAGS = '-DUSE_SSD1306'

esphomeyaml/components/display/ssd1306_spi.py

@@ -0,0 +1,71 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display, spi
+from esphomeyaml.components.spi import SPIComponent
+from esphomeyaml.const import CONF_CS_PIN, CONF_DC_PIN, CONF_EXTERNAL_VCC, \
+    CONF_ID, CONF_MODEL, \
+    CONF_RESET_PIN, CONF_SPI_ID, CONF_LAMBDA
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, \
+    gpio_output_pin_expression, process_lambda, setup_component, PollingComponent
+
+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 = vol.All(vol.Upper, vol.Replace(' ', '_'), cv.one_of(*MODELS))
+
+PLATFORM_SCHEMA = 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)
+
+
+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')]):
+            yield
+        add(ssd.set_writer(lambda_))
+
+    display.setup_display(ssd, config)
+    setup_component(ssd, config)
+
+
+BUILD_FLAGS = '-DUSE_SSD1306'

esphomeyaml/components/display/waveshare_epaper.py

@@ -0,0 +1,90 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display, spi
+from esphomeyaml.components.spi import SPIComponent
+from esphomeyaml.const import CONF_BUSY_PIN, CONF_CS_PIN, CONF_DC_PIN, CONF_FULL_UPDATE_EVERY, \
+    CONF_ID, CONF_LAMBDA, CONF_MODEL, CONF_RESET_PIN, CONF_SPI_ID
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, gpio_input_pin_expression, \
+    gpio_output_pin_expression, process_lambda, setup_component, PollingComponent
+
+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): vol.All(vol.Lower, cv.one_of(*MODELS)),
+    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)
+
+
+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')]):
+            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'

esphomeyaml/components/esp32_ble_beacon.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, CONF_TYPE, CONF_UUID, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, ArrayInitializer, Component, Pvariable, RawExpression, add, \
+    esphomelib_ns, setup_component
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+ESP32BLEBeacon = esphomelib_ns.class_('ESP32BLEBeacon', Component)
+
+CONF_MAJOR = 'major'
+CONF_MINOR = 'minor'
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLEBeacon),
+    vol.Required(CONF_TYPE): vol.All(vol.Upper, cv.one_of('IBEACON')),
+    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(ArrayInitializer(*uuid_arr, multiline=False))
+    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'

esphomeyaml/components/esp32_ble_tracker.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, ArrayInitializer, \
+    setup_component, Component
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONF_ESP32_BLE_ID = 'esp32_ble_id'
+ESP32BLETracker = esphomelib_ns.class_('ESP32BLETracker', Component)
+XiaomiSensor = esphomelib_ns.class_('XiaomiSensor', sensor.Sensor)
+XiaomiDevice = esphomelib_ns.class_('XiaomiDevice')
+XIAOMI_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(XiaomiSensor)
+})
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLETracker),
+    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def make_address_array(address):
+    addr = [HexInt(i) for i in address.parts]
+    return ArrayInitializer(*addr, multiline=False)
+
+
+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'

esphomeyaml/components/esp32_touch.py

@@ -0,0 +1,86 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_ID, CONF_SETUP_MODE, CONF_IIR_FILTER, \
+    CONF_SLEEP_DURATION, CONF_MEASUREMENT_DURATION, CONF_LOW_VOLTAGE_REFERENCE, \
+    CONF_HIGH_VOLTAGE_REFERENCE, CONF_VOLTAGE_ATTENUATION, ESP_PLATFORM_ESP32
+from esphomeyaml.core import TimePeriod
+from esphomeyaml.helpers import App, Pvariable, add, global_ns, setup_component, Component
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+
+def validate_voltage(values):
+    def validator(value):
+        if isinstance(value, float) and value.is_integer():
+            value = int(value)
+        value = cv.string(value)
+        if not value.endswith('V'):
+            value += 'V'
+        return cv.one_of(*values)(value)
+    return validator
+
+
+LOW_VOLTAGE_REFERENCE = {
+    '0.5V': global_ns.TOUCH_LVOLT_0V5,
+    '0.6V': global_ns.TOUCH_LVOLT_0V6,
+    '0.7V': global_ns.TOUCH_LVOLT_0V7,
+    '0.8V': global_ns.TOUCH_LVOLT_0V8,
+}
+HIGH_VOLTAGE_REFERENCE = {
+    '2.4V': global_ns.TOUCH_HVOLT_2V4,
+    '2.5V': global_ns.TOUCH_HVOLT_2V5,
+    '2.6V': global_ns.TOUCH_HVOLT_2V6,
+    '2.7V': global_ns.TOUCH_HVOLT_2V7,
+}
+VOLTAGE_ATTENUATION = {
+    '1.5V': global_ns.TOUCH_HVOLT_ATTEN_1V5,
+    '1V': global_ns.TOUCH_HVOLT_ATTEN_1V,
+    '0.5V': global_ns.TOUCH_HVOLT_ATTEN_0V5,
+    '0V': global_ns.TOUCH_HVOLT_ATTEN_0V,
+}
+
+ESP32TouchComponent = binary_sensor.binary_sensor_ns.class_('ESP32TouchComponent', Component)
+
+CONFIG_SCHEMA = vol.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):
+        vol.All(cv.positive_time_period, vol.Range(max=TimePeriod(microseconds=436906))),
+    vol.Optional(CONF_MEASUREMENT_DURATION):
+        vol.All(cv.positive_time_period, vol.Range(max=TimePeriod(microseconds=8192))),
+    vol.Optional(CONF_LOW_VOLTAGE_REFERENCE): validate_voltage(LOW_VOLTAGE_REFERENCE),
+    vol.Optional(CONF_HIGH_VOLTAGE_REFERENCE): validate_voltage(HIGH_VOLTAGE_REFERENCE),
+    vol.Optional(CONF_VOLTAGE_ATTENUATION): validate_voltage(VOLTAGE_ATTENUATION),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_esp32_touch_component()
+    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 * 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)
+        add(touch.set_measurement_duration(measurement_duration))
+    if CONF_LOW_VOLTAGE_REFERENCE in config:
+        value = LOW_VOLTAGE_REFERENCE[config[CONF_LOW_VOLTAGE_REFERENCE]]
+        add(touch.set_low_voltage_reference(value))
+    if CONF_HIGH_VOLTAGE_REFERENCE in config:
+        value = HIGH_VOLTAGE_REFERENCE[config[CONF_HIGH_VOLTAGE_REFERENCE]]
+        add(touch.set_high_voltage_reference(value))
+    if CONF_VOLTAGE_ATTENUATION in config:
+        value = VOLTAGE_ATTENUATION[config[CONF_VOLTAGE_ATTENUATION]]
+        add(touch.set_voltage_attenuation(value))
+
+    setup_component(touch, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'

esphomeyaml/components/fan/__init__.py

@@ -1,23 +1,146 @@
 import voluptuous as vol
 
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
+from esphomeyaml.components import mqtt
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_OSCILLATION_COMMAND_TOPIC, CONF_OSCILLATION_STATE_TOPIC, \
-    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
-from esphomeyaml.helpers import add, setup_mqtt_component
+from esphomeyaml.const import CONF_ID, CONF_MQTT_ID, CONF_OSCILLATION_COMMAND_TOPIC, \
+    CONF_OSCILLATION_STATE_TOPIC, CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC, CONF_INTERNAL, \
+    CONF_SPEED, CONF_OSCILLATING, CONF_OSCILLATION_OUTPUT, CONF_NAME
+from esphomeyaml.helpers import Application, Pvariable, add, esphomelib_ns, setup_mqtt_component, \
+    TemplateArguments, get_variable, templatable, bool_, Action, Nameable, Component
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+fan_ns = esphomelib_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): cv.publish_topic,
     vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): cv.subscribe_topic,
-}).extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA.schema)
+})
+
+FAN_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FAN_SCHEMA.schema)
 
 
-def setup_mqtt_fan(obj, config):
+FAN_SPEEDS = {
+    'OFF': FAN_SPEED_OFF,
+    'LOW': FAN_SPEED_LOW,
+    'MEDIUM': FAN_SPEED_MEDIUM,
+    'HIGH': FAN_SPEED_HIGH,
+}
+
+
+def validate_fan_speed(value):
+    return vol.All(vol.Upper, cv.one_of(*FAN_SPEEDS))(value)
+
+
+def setup_fan_core_(fan_var, mqtt_var, config):
+    if CONF_INTERNAL in config:
+        add(fan_var.set_internal(config[CONF_INTERNAL]))
+
     if CONF_OSCILLATION_STATE_TOPIC in config:
-        add(obj.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
+        add(mqtt_var.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
     if CONF_OSCILLATION_COMMAND_TOPIC in config:
-        add(obj.set_custom_oscillation_command_topic(config[CONF_OSCILLATION_COMMAND_TOPIC]))
+        add(mqtt_var.set_custom_oscillation_command_topic(config[CONF_OSCILLATION_COMMAND_TOPIC]))
     if CONF_SPEED_STATE_TOPIC in config:
-        add(obj.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
+        add(mqtt_var.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
     if CONF_SPEED_COMMAND_TOPIC in config:
-        add(obj.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
-    setup_mqtt_component(obj, config)
+        add(mqtt_var.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_fan(fan_obj, mqtt_obj, config):
+    fan_var = Pvariable(config[CONF_ID], fan_obj, has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    setup_fan_core_(fan_var, mqtt_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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_toggle_action(template_arg)
+    type = ToggleAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(arg_type)
+    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(validate_fan_speed),
+})
+
+
+@ACTION_REGISTRY.register(CONF_FAN_TURN_ON, FAN_TURN_ON_ACTION_SCHEMA)
+def fan_turn_on_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(arg_type)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_OSCILLATING in config:
+        for template_ in templatable(config[CONF_OSCILLATING], arg_type, bool_):
+            yield None
+        add(action.set_oscillating(template_))
+    if CONF_SPEED in config:
+        for template_ in templatable(config[CONF_SPEED], arg_type, FanSpeed):
+            yield None
+        add(action.set_speed(template_))
+    yield action
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'fan', config, include_state=True, include_command=True)
+    if ret is None:
+        return None
+    if CONF_OSCILLATION_OUTPUT in config:
+        default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'oscillation/state')
+        ret['oscillation_state_topic'] = config.get(CONF_OSCILLATION_STATE_TOPIC, default)
+        default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'oscillation/command')
+        ret['oscillation_command__topic'] = config.get(CONF_OSCILLATION_COMMAND_TOPIC, default)
+    return ret

esphomeyaml/components/fan/binary.py

@@ -1,23 +1,32 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import fan
-from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
-from esphomeyaml.helpers import App, add, get_variable, variable
+from esphomeyaml.components import fan, output
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
+from esphomeyaml.helpers import App, add, get_variable, variable, setup_component
 
-PLATFORM_SCHEMA = fan.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('binary_fan'): cv.register_variable_id,
-    vol.Required(CONF_OUTPUT): cv.variable_id,
-    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.variable_id,
-})
+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):
-    output = get_variable(config[CONF_OUTPUT])
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+
     rhs = App.make_fan(config[CONF_NAME])
-    fan_struct = variable('Application::FanStruct', config[CONF_ID], rhs)
-    add(fan_struct.Poutput.set_binary(output))
+    fan_struct = variable(config[CONF_MAKE_ID], rhs)
+    add(fan_struct.Poutput.set_binary(output_))
     if CONF_OSCILLATION_OUTPUT in config:
-        oscillation_output = get_variable(config[CONF_OSCILLATION_OUTPUT])
+        for oscillation_output in get_variable(config[CONF_OSCILLATION_OUTPUT]):
+            yield
         add(fan_struct.Poutput.set_oscillation(oscillation_output))
-    fan.setup_mqtt_fan(fan_struct.Pmqtt, config)
+
+    fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)
+    setup_component(fan_struct.Poutput, config)
+
+
+def to_hass_config(data, config):
+    return fan.core_to_hass_config(data, config)

esphomeyaml/components/fan/speed.py

@@ -1,40 +1,54 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import fan
-from esphomeyaml.const import CONF_HIGH, CONF_ID, CONF_LOW, \
-    CONF_MEDIUM, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_SPEED, \
-    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphomeyaml.components import fan, mqtt, output
+from esphomeyaml.const import CONF_HIGH, CONF_LOW, CONF_MAKE_ID, CONF_MEDIUM, CONF_NAME, \
+    CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_SPEED, CONF_SPEED_COMMAND_TOPIC, \
+    CONF_SPEED_STATE_TOPIC
 from esphomeyaml.helpers import App, add, get_variable, variable
 
-PLATFORM_SCHEMA = fan.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('speed_fan'): cv.register_variable_id,
-    vol.Required(CONF_OUTPUT): cv.variable_id,
+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.variable_id,
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput),
     vol.Optional(CONF_SPEED): vol.Schema({
-        vol.Required(CONF_LOW): cv.zero_to_one_float,
-        vol.Required(CONF_MEDIUM): cv.zero_to_one_float,
-        vol.Required(CONF_HIGH): cv.zero_to_one_float,
+        vol.Required(CONF_LOW): cv.percentage,
+        vol.Required(CONF_MEDIUM): cv.percentage,
+        vol.Required(CONF_HIGH): cv.percentage,
     }),
-})
+}).extend(cv.COMPONENT_SCHEMA.schema))
 
 
 def to_code(config):
-    output = get_variable(config[CONF_OUTPUT])
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
     rhs = App.make_fan(config[CONF_NAME])
-    fan_struct = variable('Application::FanStruct', config[CONF_ID], rhs)
+    fan_struct = variable(config[CONF_MAKE_ID], rhs)
     if CONF_SPEED in config:
         speeds = config[CONF_SPEED]
-        add(fan_struct.Poutput.set_speed(output, 0.0,
+        add(fan_struct.Poutput.set_speed(output_,
                                          speeds[CONF_LOW],
                                          speeds[CONF_MEDIUM],
                                          speeds[CONF_HIGH]))
     else:
-        add(fan_struct.Poutput.set_speed(output))
+        add(fan_struct.Poutput.set_speed(output_))
 
     if CONF_OSCILLATION_OUTPUT in config:
-        oscillation_output = get_variable(config[CONF_OSCILLATION_OUTPUT])
+        for oscillation_output in get_variable(config[CONF_OSCILLATION_OUTPUT]):
+            yield
         add(fan_struct.Poutput.set_oscillation(oscillation_output))
-    fan.setup_mqtt_fan(fan_struct.Pmqtt, config)
+
+    fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)
+
+
+def to_hass_config(data, config):
+    ret = fan.core_to_hass_config(data, config)
+    if ret is None:
+        return None
+    default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'speed/state')
+    ret['speed_state_topic'] = config.get(CONF_SPEED_STATE_TOPIC, default)
+    default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'speed/command')
+    ret['speed_command__topic'] = config.get(CONF_SPEED_COMMAND_TOPIC, default)
+    return ret

esphomeyaml/components/font.py

@@ -0,0 +1,121 @@
+# coding=utf-8
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import core
+from esphomeyaml.components import display
+from esphomeyaml.const import CONF_FILE, CONF_GLYPHS, CONF_ID, CONF_SIZE
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
+    relative_path
+
+DEPENDENCIES = ['display']
+
+Font = display.display_ns.class_('Font')
+Glyph = display.display_ns.class_('Glyph')
+
+
+def validate_glyphs(value):
+    if isinstance(value, list):
+        value = vol.Schema([cv.string])(value)
+    value = vol.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
+        elif len(x_) > len(y_):
+            return 1
+        else:
+            raise vol.Invalid(u"Found duplicate glyph {}".format(x))
+
+    value.sort(cmp=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. "
+                          "(pip2 install pillow)")
+
+    if PIL.__version__[0] < '4':
+        raise vol.Invalid("Please update your pillow installation to at least 4.0.x. "
+                          "(pip2 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 = vol.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(None),
+})
+
+CONFIG_SCHEMA = vol.All(validate_pillow_installed, cv.ensure_list, [FONT_SCHEMA])
+
+
+def to_code(config):
+    from PIL import ImageFont
+
+    for conf in config:
+        path = relative_path(conf[CONF_FILE])
+        try:
+            font = ImageFont.truetype(path, conf[CONF_SIZE])
+        except Exception as e:
+            raise core.ESPHomeYAMLError(u"Could not load truetype file {}: {}".format(path, e))
+
+        ascent, descent = font.getmetrics()
+
+        glyph_args = {}
+        data = []
+        for glyph in conf[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
+
+        raw_data = MockObj(conf[CONF_RAW_DATA_ID])
+        add(RawExpression('static const uint8_t {}[{}] PROGMEM = {}'.format(
+            raw_data, len(data),
+            ArrayInitializer(*[HexInt(x) for x in data], multiline=False))))
+
+        glyphs = []
+        for glyph in conf[CONF_GLYPHS]:
+            glyphs.append(Glyph(glyph, raw_data, *glyph_args[glyph]))
+
+        rhs = App.make_font(ArrayInitializer(*glyphs), ascent, ascent + descent)
+        Pvariable(conf[CONF_ID], rhs)

esphomeyaml/components/globals.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_INITIAL_VALUE, CONF_RESTORE_VALUE, CONF_TYPE
+from esphomeyaml.helpers import App, Component, Pvariable, RawExpression, TemplateArguments, add, \
+    esphomelib_ns, setup_component
+
+GlobalVariableComponent = esphomelib_ns.class_('GlobalVariableComponent', Component)
+
+GLOBAL_VAR_SCHEMA = vol.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)
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [GLOBAL_VAR_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        type_ = RawExpression(conf[CONF_TYPE])
+        template_args = TemplateArguments(type_)
+        res_type = GlobalVariableComponent.template(template_args)
+        initial_value = None
+        if CONF_INITIAL_VALUE in conf:
+            initial_value = RawExpression(conf[CONF_INITIAL_VALUE])
+        rhs = App.Pmake_global_variable(template_args, initial_value)
+        glob = Pvariable(conf[CONF_ID], rhs, type=res_type)
+
+        if conf.get(CONF_RESTORE_VALUE, False):
+            hash_ = hash(conf[CONF_ID].id) % 2**32
+            add(glob.set_restore_value(hash_))
+
+        setup_component(glob, conf)

esphomeyaml/components/i2c.py

@@ -2,15 +2,35 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
-from esphomeyaml.const import CONF_FREQUENCY, CONF_SCL, CONF_SDA
-from esphomeyaml.helpers import App, add
+from esphomeyaml.const import CONF_FREQUENCY, CONF_SCL, CONF_SDA, CONF_SCAN, CONF_ID, \
+    CONF_RECEIVE_TIMEOUT
+from esphomeyaml.helpers import App, add, Pvariable, esphomelib_ns, setup_component, Component
+
+I2CComponent = esphomelib_ns.class_('I2CComponent', Component)
+I2CDevice = pins.I2CDevice
 
 CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(I2CComponent),
     vol.Required(CONF_SDA, default='SDA'): pins.input_output_pin,
     vol.Required(CONF_SCL, default='SCL'): pins.input_output_pin,
-    vol.Optional(CONF_FREQUENCY): vol.All(cv.only_on_esp32, cv.positive_int),
-})
+    vol.Optional(CONF_FREQUENCY): vol.All(cv.frequency, vol.Range(min=0, min_included=False)),
+    vol.Optional(CONF_SCAN): 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):
-    add(App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_FREQUENCY)))
+    rhs = App.init_i2c(config[CONF_SDA], config[CONF_SCL], config.get(CONF_SCAN))
+    i2c = Pvariable(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'

esphomeyaml/components/image.py

@@ -0,0 +1,65 @@
+# coding=utf-8
+import logging
+
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import core
+from esphomeyaml.components import display, font
+from esphomeyaml.const import CONF_FILE, CONF_ID, CONF_RESIZE
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
+    relative_path
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['display']
+
+Image_ = display.display_ns.class_('Image')
+
+CONF_RAW_DATA_ID = 'raw_data_id'
+
+IMAGE_SCHEMA = vol.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(None),
+})
+
+CONFIG_SCHEMA = vol.All(font.validate_pillow_installed, cv.ensure_list, [IMAGE_SCHEMA])
+
+
+def to_code(config):
+    from PIL import Image
+
+    for conf in config:
+        path = relative_path(conf[CONF_FILE])
+        try:
+            image = Image.open(path)
+        except Exception as e:
+            raise core.ESPHomeYAMLError(u"Could not load image file {}: {}".format(path, e))
+
+        if CONF_RESIZE in conf:
+            image.thumbnail(conf[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)
+
+        raw_data = MockObj(conf[CONF_RAW_DATA_ID])
+        add(RawExpression('static const uint8_t {}[{}] PROGMEM = {}'.format(
+            raw_data, len(data),
+            ArrayInitializer(*[HexInt(x) for x in data], multiline=False))))
+
+        rhs = App.make_image(raw_data, width, height)
+        Pvariable(conf[CONF_ID], rhs)

esphomeyaml/components/ir_transmitter.py

@@ -1,23 +0,0 @@
-import voluptuous as vol
-
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
-
-ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
-
-IR_TRANSMITTER_COMPONENT_CLASS = 'switch_::IRTransmitterComponent'
-
-CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
-    cv.GenerateID('ir_transmitter'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Optional(CONF_CARRIER_DUTY_PERCENT): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),
-})])
-
-
-def to_code(config):
-    for conf in config:
-        pin = exp_gpio_output_pin(conf[CONF_PIN])
-        rhs = App.make_ir_transmitter(pin, conf.get(CONF_CARRIER_DUTY_PERCENT))
-        Pvariable(IR_TRANSMITTER_COMPONENT_CLASS, conf[CONF_ID], rhs)

esphomeyaml/components/light/__init__.py

@@ -1,13 +1,480 @@
+import voluptuous as vol
+
+from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
+from esphomeyaml.components import mqtt
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH
-from esphomeyaml.helpers import add, setup_mqtt_component
+from esphomeyaml.const import CONF_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 esphomeyaml.helpers import Action, Application, ArrayInitializer, Component, Nameable, \
+    Pvariable, StructInitializer, TemplateArguments, add, add_job, esphomelib_ns, float_, \
+    get_variable, process_lambda, setup_mqtt_component, std_string, templatable, uint32
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
-}).extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA.schema)
+})
+
+# Base
+light_ns = esphomelib_ns.namespace('light')
+LightState = light_ns.class_('LightState', Nameable, Component)
+MakeLight = Application.struct('MakeLight')
+LightOutput = light_ns.class_('LightOutput')
+FastLEDLightOutputComponent = light_ns.class_('FastLEDLightOutputComponent', LightOutput)
+FastLEDLightOutputComponentRef = FastLEDLightOutputComponent.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)
+BaseFastLEDLightEffect = light_ns.class_('BaseFastLEDLightEffect', LightEffect)
+FastLEDLambdaLightEffect = light_ns.class_('FastLEDLambdaLightEffect', BaseFastLEDLightEffect)
+FastLEDRainbowLightEffect = light_ns.class_('FastLEDRainbowLightEffect', BaseFastLEDLightEffect)
+FastLEDColorWipeEffect = light_ns.class_('FastLEDColorWipeEffect', BaseFastLEDLightEffect)
+FastLEDColorWipeEffectColor = light_ns.class_('FastLEDColorWipeEffectColor', BaseFastLEDLightEffect)
+FastLEDScanEffect = light_ns.class_('FastLEDScanEffect', BaseFastLEDLightEffect)
+FastLEDScanEffectColor = light_ns.class_('FastLEDScanEffectColor', BaseFastLEDLightEffect)
+FastLEDTwinkleEffect = light_ns.class_('FastLEDTwinkleEffect', BaseFastLEDLightEffect)
+FastLEDRandomTwinkleEffect = light_ns.class_('FastLEDRandomTwinkleEffect', BaseFastLEDLightEffect)
+FastLEDFireworksEffect = light_ns.class_('FastLEDFireworksEffect', BaseFastLEDLightEffect)
+FastLEDFlickerEffect = light_ns.class_('FastLEDFlickerEffect', BaseFastLEDLightEffect)
+
+CONF_STROBE = 'strobe'
+CONF_FLICKER = 'flicker'
+CONF_FASTLED_LAMBDA = 'fastled_lambda'
+CONF_FASTLED_RAINBOW = 'fastled_rainbow'
+CONF_FASTLED_COLOR_WIPE = 'fastled_color_wipe'
+CONF_FASTLED_SCAN = 'fastled_scan'
+CONF_FASTLED_TWINKLE = 'fastled_twinkle'
+CONF_FASTLED_RANDOM_TWINKLE = 'fastled_random_twinkle'
+CONF_FASTLED_FIREWORKS = 'fastled_fireworks'
+CONF_FASTLED_FLICKER = 'fastled_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]
+FASTLED_EFFECTS = RGB_EFFECTS + [CONF_FASTLED_LAMBDA, CONF_FASTLED_RAINBOW, CONF_FASTLED_COLOR_WIPE,
+                                 CONF_FASTLED_SCAN, CONF_FASTLED_TWINKLE,
+                                 CONF_FASTLED_RANDOM_TWINKLE, CONF_FASTLED_FIREWORKS,
+                                 CONF_FASTLED_FLICKER]
+
+EFFECTS_SCHEMA = vol.Schema({
+    vol.Optional(CONF_LAMBDA): vol.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): vol.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): vol.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, [vol.All(vol.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): vol.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_FASTLED_LAMBDA): vol.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_FASTLED_RAINBOW): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRainbowLightEffect),
+        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_FASTLED_COLOR_WIPE): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDColorWipeEffect),
+        vol.Optional(CONF_NAME, default="Color Wipe"): cv.string,
+        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list, [vol.Schema({
+            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_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_FASTLED_SCAN): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDScanEffect),
+        vol.Optional(CONF_NAME, default="Scan"): cv.string,
+        vol.Optional(CONF_MOVE_INTERVAL): cv.positive_time_period_milliseconds,
+    }),
+    vol.Optional(CONF_FASTLED_TWINKLE): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDTwinkleEffect),
+        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_FASTLED_RANDOM_TWINKLE): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRandomTwinkleEffect),
+        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_FASTLED_FIREWORKS): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDFireworksEffect),
+        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_FASTLED_FLICKER): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDFlickerEffect),
+        vol.Optional(CONF_NAME, default="FastLED Flicker"): cv.string,
+        vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
+        vol.Optional(CONF_INTENSITY): cv.percentage,
+    }),
+})
 
 
-def setup_mqtt_light_component(obj, config):
+def validate_effects(allowed_effects):
+    def validator(value):
+        value = cv.ensure_list(value)
+        names = set()
+        ret = []
+        for i, effect in enumerate(value):
+            if not isinstance(effect, dict):
+                raise vol.Invalid("Each effect must be a dictionary, not {}".format(type(value)))
+            if len(effect) > 1:
+                raise vol.Invalid("Each entry in the 'effects:' option must be a single effect.")
+            if not effect:
+                raise vol.Invalid("Found no effect for the {}th entry in 'effects:'!".format(i))
+            key = next(iter(effect.keys()))
+            if key not in allowed_effects:
+                raise vol.Invalid("The effect '{}' does not exist or is not allowed for this "
+                                  "light type".format(key))
+            effect[key] = effect[key] or {}
+            conf = EFFECTS_SCHEMA(effect)
+            name = conf[key][CONF_NAME]
+            if name in names:
+                raise vol.Invalid(u"Found the effect name '{}' twice. All effects must have "
+                                  u"unique names".format(name))
+            names.add(name)
+            ret.append(conf)
+        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], []):
+            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(ArrayInitializer(*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_FASTLED_LAMBDA:
+        args = [(FastLEDLightOutputComponentRef, 'it')]
+        for lambda_ in process_lambda(config[CONF_LAMBDA], args):
+            yield None
+        yield FastLEDLambdaLightEffect.new(config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL])
+    elif key == CONF_FASTLED_RAINBOW:
+        rhs = FastLEDRainbowLightEffect.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_FASTLED_COLOR_WIPE:
+        rhs = FastLEDColorWipeEffect.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(
+                FastLEDColorWipeEffectColor,
+                ('r', color[CONF_RED]),
+                ('g', color[CONF_GREEN]),
+                ('b', color[CONF_BLUE]),
+                ('random', color[CONF_RANDOM]),
+                ('num_leds', color[CONF_NUM_LEDS]),
+            ))
+        if colors:
+            add(effect.set_colors(ArrayInitializer(*colors)))
+        yield effect
+    elif key == CONF_FASTLED_SCAN:
+        rhs = FastLEDScanEffect.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_FASTLED_TWINKLE:
+        rhs = FastLEDTwinkleEffect.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_FASTLED_RANDOM_TWINKLE:
+        rhs = FastLEDRandomTwinkleEffect.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_FASTLED_FIREWORKS:
+        rhs = FastLEDFireworksEffect.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_FASTLED_FLICKER:
+        rhs = FastLEDFlickerEffect.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, mqtt_var, config):
+    if CONF_INTERNAL in config:
+        add(light_var.set_internal(config[CONF_INTERNAL]))
     if CONF_DEFAULT_TRANSITION_LENGTH in config:
-        add(obj.set_default_transition_length(config[CONF_DEFAULT_TRANSITION_LENGTH]))
-    setup_mqtt_component(obj, config)
+        add(light_var.set_default_transition_length(config[CONF_DEFAULT_TRANSITION_LENGTH]))
+    if CONF_GAMMA_CORRECT in config:
+        add(light_var.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
+    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(ArrayInitializer(*effects)))
+
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_light(light_obj, mqtt_obj, config):
+    light_var = Pvariable(config[CONF_ID], light_obj, has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    add_job(setup_light_core_, light_var, mqtt_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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    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], arg_type, 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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    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], arg_type, 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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    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], arg_type, uint32):
+            yield None
+        add(action.set_transition_length(template_))
+    if CONF_FLASH_LENGTH in config:
+        for template_ in templatable(config[CONF_FLASH_LENGTH], arg_type, uint32):
+            yield None
+        add(action.set_flash_length(template_))
+    if CONF_BRIGHTNESS in config:
+        for template_ in templatable(config[CONF_BRIGHTNESS], arg_type, float_):
+            yield None
+        add(action.set_brightness(template_))
+    if CONF_RED in config:
+        for template_ in templatable(config[CONF_RED], arg_type, float_):
+            yield None
+        add(action.set_red(template_))
+    if CONF_GREEN in config:
+        for template_ in templatable(config[CONF_GREEN], arg_type, float_):
+            yield None
+        add(action.set_green(template_))
+    if CONF_BLUE in config:
+        for template_ in templatable(config[CONF_BLUE], arg_type, float_):
+            yield None
+        add(action.set_blue(template_))
+    if CONF_WHITE in config:
+        for template_ in templatable(config[CONF_WHITE], arg_type, float_):
+            yield None
+        add(action.set_white(template_))
+    if CONF_COLOR_TEMPERATURE in config:
+        for template_ in templatable(config[CONF_COLOR_TEMPERATURE], arg_type, float_):
+            yield None
+        add(action.set_color_temperature(template_))
+    if CONF_EFFECT in config:
+        for template_ in templatable(config[CONF_EFFECT], arg_type, std_string):
+            yield None
+        add(action.set_effect(template_))
+    yield action
+
+
+def core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=True,
+                        white_value=True):
+    ret = mqtt.build_hass_config(data, 'light', config, include_state=True, include_command=True,
+                                 platform='mqtt_json')
+    if ret is None:
+        return None
+    if brightness:
+        ret['brightness'] = True
+    if rgb:
+        ret['rgb'] = True
+    if color_temp:
+        ret['color_temp'] = True
+    if white_value:
+        ret['white_value'] = True
+    for effect in config.get(CONF_EFFECTS, []):
+        ret["effect"] = True
+        effects = ret.setdefault("effect_list", [])
+        effects.append(next(x for x in effect.values())[CONF_NAME])
+    return ret

esphomeyaml/components/light/binary.py

@@ -1,19 +1,26 @@
-
 import voluptuous as vol
 
+from esphomeyaml.components import light, output
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light
-from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_OUTPUT
-from esphomeyaml.helpers import App, get_variable, variable
+from esphomeyaml.const import CONF_EFFECTS, CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphomeyaml.helpers import App, get_variable, setup_component, variable
 
-PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('binary_light'): cv.register_variable_id,
-    vol.Required(CONF_OUTPUT): cv.variable_id,
-})
+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):
-    output = get_variable(config[CONF_OUTPUT])
-    rhs = App.make_binary_light(config[CONF_NAME], output)
-    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
-    light.setup_mqtt_light_component(light_struct.Pmqtt, config)
+    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, light_struct.Pmqtt, config)
+    setup_component(light_struct.Pstate, config)
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=False, rgb=False, color_temp=False,
+                                     white_value=False)

esphomeyaml/components/light/cwww.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light, output
+from esphomeyaml.components.light.rgbww import validate_cold_white_colder, \
+    validate_color_temperature
+from esphomeyaml.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 esphomeyaml.helpers import App, get_variable, variable, setup_component
+
+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, light_struct.Pmqtt, config)
+    setup_component(light_struct.Pstate, config)
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=False, color_temp=True,
+                                     white_value=False)

esphomeyaml/components/light/fastled_clockless.py

@@ -0,0 +1,109 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import light
+from esphomeyaml.components.power_supply import PowerSupplyComponent
+from esphomeyaml.const import CONF_CHIPSET, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
+    CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, \
+    CONF_RGB_ORDER, CONF_EFFECTS, CONF_COLOR_CORRECT
+from esphomeyaml.helpers import App, Application, RawExpression, TemplateArguments, add, \
+    get_variable, variable, setup_component
+
+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(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
+
+    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*TYPES)),
+    vol.Required(CONF_PIN): pins.output_pin,
+
+    vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
+    vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_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.FASTLED_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, make.Pmqtt, config)
+    setup_component(fast_led, config)
+
+
+BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
+                                     white_value=False)

esphomeyaml/components/light/fastled_spi.py

@@ -0,0 +1,89 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import light
+from esphomeyaml.components.power_supply import PowerSupplyComponent
+from esphomeyaml.const import CONF_CHIPSET, CONF_CLOCK_PIN, CONF_DATA_PIN, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, \
+    CONF_NAME, CONF_NUM_LEDS, CONF_POWER_SUPPLY, CONF_RGB_ORDER, CONF_EFFECTS, CONF_COLOR_CORRECT
+from esphomeyaml.helpers import App, Application, RawExpression, TemplateArguments, add, \
+    get_variable, variable, setup_component
+
+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(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
+
+    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*CHIPSETS)),
+    vol.Required(CONF_DATA_PIN): pins.output_pin,
+    vol.Required(CONF_CLOCK_PIN): pins.output_pin,
+
+    vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
+    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
+    vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_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.FASTLED_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, make.Pmqtt, config)
+    setup_component(fast_led, config)
+
+
+BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
+                                     white_value=False)

esphomeyaml/components/light/monochromatic.py

@@ -1,23 +1,29 @@
 import voluptuous as vol
 
+from esphomeyaml.components import light, output
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light
-from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_ID, \
-    CONF_NAME, CONF_OUTPUT
-from esphomeyaml.helpers import App, add, get_variable, variable
+from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, \
+    CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphomeyaml.helpers import App, get_variable, setup_component, variable
 
-PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('monochromatic_light'): cv.register_variable_id,
-    vol.Required(CONF_OUTPUT): cv.variable_id,
+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,
-})
+    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):
-    output = get_variable(config[CONF_OUTPUT])
-    rhs = App.make_monochromatic_light(config[CONF_NAME], output)
-    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
-    if CONF_GAMMA_CORRECT in config:
-        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
-    light.setup_mqtt_light_component(light_struct.Pmqtt, config)
+    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, light_struct.Pmqtt, config)
+    setup_component(light_struct.Pstate, config)
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=False, color_temp=False,
+                                     white_value=False)

esphomeyaml/components/light/rgb.py

@@ -1,27 +1,35 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light
+from esphomeyaml.components import light, output
 from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_GREEN, CONF_ID, CONF_NAME, CONF_RED
-from esphomeyaml.helpers import App, add, get_variable, variable
+    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, variable, setup_component
 
-PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('rgb_light'): cv.register_variable_id,
-    vol.Required(CONF_RED): cv.variable_id,
-    vol.Required(CONF_GREEN): cv.variable_id,
-    vol.Required(CONF_BLUE): cv.variable_id,
+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,
-})
+    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):
-    red = get_variable(config[CONF_RED])
-    green = get_variable(config[CONF_GREEN])
-    blue = get_variable(config[CONF_BLUE])
+    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('Application::LightStruct', config[CONF_ID], rhs)
-    if CONF_GAMMA_CORRECT in config:
-        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
-    light.setup_mqtt_light_component(light_struct.Pmqtt, config)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    setup_component(light_struct.Pstate, config)
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
+                                     white_value=False)

esphomeyaml/components/light/rgbw.py

@@ -1,29 +1,38 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light
+from esphomeyaml.components import light, output
 from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_GREEN, CONF_ID, CONF_NAME, CONF_RED, CONF_WHITE
-from esphomeyaml.helpers import App, get_variable, variable, add
+    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_WHITE, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, variable, setup_component
 
-PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('rgbw_light'): cv.register_variable_id,
-    vol.Required(CONF_RED): cv.variable_id,
-    vol.Required(CONF_GREEN): cv.variable_id,
-    vol.Required(CONF_BLUE): cv.variable_id,
-    vol.Required(CONF_WHITE): cv.variable_id,
+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,
-})
+    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):
-    red = get_variable(config[CONF_RED])
-    green = get_variable(config[CONF_GREEN])
-    blue = get_variable(config[CONF_BLUE])
-    white = get_variable(config[CONF_WHITE])
+    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('Application::LightStruct', config[CONF_ID], rhs)
-    if CONF_GAMMA_CORRECT in config:
-        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
-    light.setup_mqtt_light_component(light_struct.Pmqtt, config)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    setup_component(light_struct.Pstate, config)
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
+                                     white_value=True)

esphomeyaml/components/light/rgbww.py

@@ -0,0 +1,68 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light, output
+from esphomeyaml.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 esphomeyaml.helpers import App, get_variable, variable, setup_component
+
+
+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, light_struct.Pmqtt, config)
+    setup_component(light_struct.Pstate, config)
+
+
+def to_hass_config(data, config):
+    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=True,
+                                     white_value=True)

esphomeyaml/components/logger.py

@@ -1,60 +1,129 @@
+import re
+
 import voluptuous as vol
 
+from esphomeyaml.automation import ACTION_REGISTRY, LambdaAction
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BAUD_RATE, CONF_ID, CONF_LEVEL, CONF_LOGGER, CONF_LOGS, \
-    CONF_LOG_TOPIC, CONF_TX_BUFFER_SIZE
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, RawExpression, add, exp_empty_optional
+from esphomeyaml.const import CONF_ARGS, CONF_BAUD_RATE, CONF_FORMAT, CONF_ID, CONF_LEVEL, \
+    CONF_LOGS, CONF_TAG, CONF_TX_BUFFER_SIZE
+from esphomeyaml.core import ESPHomeYAMLError, Lambda
+from esphomeyaml.helpers import App, Pvariable, RawExpression, TemplateArguments, add, \
+    esphomelib_ns, global_ns, process_lambda, statement, Component
 
-LOG_LEVELS = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE']
+LOG_LEVELS = {
+    'NONE': global_ns.ESPHOMELIB_LOG_LEVEL_NONE,
+    'ERROR': global_ns.ESPHOMELIB_LOG_LEVEL_ERROR,
+    'WARN': global_ns.ESPHOMELIB_LOG_LEVEL_WARN,
+    'INFO': global_ns.ESPHOMELIB_LOG_LEVEL_INFO,
+    'DEBUG': global_ns.ESPHOMELIB_LOG_LEVEL_DEBUG,
+    'VERBOSE': global_ns.ESPHOMELIB_LOG_LEVEL_VERBOSE,
+    'VERY_VERBOSE': global_ns.ESPHOMELIB_LOG_LEVEL_VERY_VERBOSE,
+}
 
-is_log_level = vol.All(vol.Upper, vol.Any(*LOG_LEVELS))
+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,
+}
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
-    cv.GenerateID(CONF_LOGGER): cv.register_variable_id,
-    vol.Optional(CONF_BAUD_RATE): cv.positive_int,
-    vol.Optional(CONF_LOG_TOPIC): vol.Any(None, '', cv.publish_topic),
-    vol.Optional(CONF_TX_BUFFER_SIZE): cv.positive_int,
+LOG_LEVEL_SEVERITY = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE', 'VERY_VERBOSE']
+
+# pylint: disable=invalid-name
+is_log_level = vol.All(vol.Upper, cv.one_of(*LOG_LEVELS))
+
+
+def validate_local_no_higher_than_global(value):
+    global_level = value.get(CONF_LEVEL, 'DEBUG')
+    for tag, level in value.get(CONF_LOGS, {}).iteritems():
+        if LOG_LEVEL_SEVERITY.index(level) > LOG_LEVEL_SEVERITY.index(global_level):
+            raise ESPHomeYAMLError(u"The local log level {} for {} must be less severe than the "
+                                   u"global log level {}.".format(level, tag, global_level))
+    return value
+
+
+LogComponent = esphomelib_ns.class_('LogComponent', Component)
+
+CONFIG_SCHEMA = vol.All(vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(LogComponent),
+    vol.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
+    vol.Optional(CONF_TX_BUFFER_SIZE): cv.validate_bytes,
     vol.Optional(CONF_LEVEL): is_log_level,
     vol.Optional(CONF_LOGS): vol.Schema({
         cv.string: is_log_level,
     })
-})
-
-
-def esphomelib_log_level(level):
-    return u'ESPHOMELIB_LOG_LEVEL_{}'.format(level)
-
-
-def exp_log_level(level):
-    return RawExpression(esphomelib_log_level(level))
+}), validate_local_no_higher_than_global)
 
 
 def to_code(config):
-    baud_rate = config.get(CONF_BAUD_RATE)
-    if baud_rate is None and CONF_LOG_TOPIC in config:
-        baud_rate = 115200
-    log_topic = None
-    if CONF_LOG_TOPIC in config:
-        if not config[CONF_LOG_TOPIC]:
-            log_topic = exp_empty_optional(u'std::string')
-        else:
-            log_topic = config[CONF_LOG_TOPIC]
-    rhs = App.init_log(baud_rate, log_topic)
-    log = Pvariable(u'LogComponent', config[CONF_ID], rhs)
+    rhs = App.init_log(config.get(CONF_BAUD_RATE))
+    log = Pvariable(config[CONF_ID], rhs)
     if CONF_TX_BUFFER_SIZE in config:
         add(log.set_tx_buffer_size(config[CONF_TX_BUFFER_SIZE]))
     if CONF_LEVEL in config:
-        add(log.set_global_log_level(exp_log_level(config[CONF_LEVEL])))
+        add(log.set_global_log_level(LOG_LEVELS[config[CONF_LEVEL]]))
     for tag, level in config.get(CONF_LOGS, {}).iteritems():
-        global_level = config.get(CONF_LEVEL, 'DEBUG')
-        if LOG_LEVELS.index(level) > LOG_LEVELS.index(global_level):
-            raise ESPHomeYAMLError(u"The local log level {} for {} must be less severe than the "
-                                   u"global log level {}.".format(level, tag, global_level))
-        add(log.set_log_level(tag, exp_log_level(level)))
+        add(log.set_log_level(tag, LOG_LEVELS[level]))
 
 
-def get_build_flags(config):
+def required_build_flags(config):
     if CONF_LEVEL in config:
-        return u'-DESPHOMELIB_LOG_LEVEL={}'.format(esphomelib_log_level(config[CONF_LEVEL]))
-    return u''
+        return u'-DESPHOMELIB_LOG_LEVEL={}'.format(str(LOG_LEVELS[config[CONF_LEVEL]]))
+    return None
+
+
+def maybe_simple_message(schema):
+    def validator(value):
+        if isinstance(value, dict):
+            return vol.Schema(schema)(value)
+        return vol.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 "%%"
+    """
+    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): vol.All(cv.ensure_list, [cv.lambda_]),
+    vol.Optional(CONF_LEVEL, default="DEBUG"): vol.All(vol.Upper, cv.one_of(*LOG_LEVEL_TO_ESP_LOG)),
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
+    args = [RawExpression(unicode(x)) for x in config[CONF_ARGS]]
+
+    text = unicode(statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args)))
+
+    for lambda_ in process_lambda(Lambda(text), [(arg_type, 'x')]):
+        yield None
+    rhs = LambdaAction.new(template_arg, lambda_)
+    type = LambdaAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphomeyaml/components/mqtt.py

@@ -1,25 +1,55 @@
+from collections import OrderedDict
+import re
+
 import voluptuous as vol
 
+from esphomeyaml import automation
+from esphomeyaml.automation import ACTION_REGISTRY
+from esphomeyaml.components import logger
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_DISCOVERY, \
-    CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, CONF_ID, CONF_MQTT, CONF_PASSWORD, \
-    CONF_PAYLOAD, CONF_PORT, CONF_QOS, CONF_RETAIN, CONF_TOPIC, CONF_TOPIC_PREFIX, CONF_USERNAME, \
-    CONF_WILL_MESSAGE, CONF_CLIENT_ID
-from esphomeyaml.helpers import App, Pvariable, StructInitializer, add, exp_empty_optional
+from esphomeyaml.const import CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_CLIENT_ID, CONF_DISCOVERY, \
+    CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, CONF_ID, CONF_KEEPALIVE, CONF_LEVEL, \
+    CONF_LOG_TOPIC, CONF_ON_MESSAGE, CONF_PASSWORD, CONF_PAYLOAD, CONF_PORT, CONF_QOS, \
+    CONF_REBOOT_TIMEOUT, CONF_RETAIN, CONF_SHUTDOWN_MESSAGE, CONF_SSL_FINGERPRINTS, CONF_TOPIC, \
+    CONF_TOPIC_PREFIX, CONF_TRIGGER_ID, CONF_USERNAME, CONF_WILL_MESSAGE, CONF_ON_JSON_MESSAGE, \
+    CONF_STATE_TOPIC, CONF_MQTT, CONF_ESPHOMEYAML, CONF_NAME, CONF_AVAILABILITY, \
+    CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_INTERNAL
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, RawExpression, \
+    StructInitializer, TemplateArguments, add, esphomelib_ns, optional, std_string, templatable, \
+    uint8, bool_, JsonObjectRef, process_lambda, JsonObjectConstRef, Component, Action, Trigger
 
-MQTT_WILL_BIRTH_SCHEMA = vol.Any(None, vol.Schema({
+
+def validate_message_just_topic(value):
+    value = cv.publish_topic(value)
+    return MQTT_MESSAGE_BASE({CONF_TOPIC: value})
+
+
+MQTT_MESSAGE_BASE = vol.Schema({
     vol.Required(CONF_TOPIC): cv.publish_topic,
-    vol.Required(CONF_PAYLOAD): cv.mqtt_payload,
-    vol.Optional(CONF_QOS, default=0): vol.All(vol.Coerce(int), vol.In([0, 1, 2])),
+    vol.Optional(CONF_QOS, default=0): cv.mqtt_qos,
     vol.Optional(CONF_RETAIN, default=True): cv.boolean,
+})
+
+MQTT_MESSAGE_TEMPLATE_SCHEMA = vol.Any(None, MQTT_MESSAGE_BASE, validate_message_just_topic)
+
+MQTT_MESSAGE_SCHEMA = vol.Any(None, MQTT_MESSAGE_BASE.extend({
+    vol.Required(CONF_PAYLOAD): cv.mqtt_payload,
 }))
 
+mqtt_ns = esphomelib_ns.namespace('mqtt')
+MQTTMessage = mqtt_ns.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)
+
 
 def validate_broker(value):
     value = cv.string_strict(value)
-    if value.endswith(u'.local'):
-        raise vol.Invalid(u"MQTT server addresses ending with '.local' are currently unsupported."
-                          u" Please specify the static IP instead.")
     if u':' in value:
         raise vol.Invalid(u"Please specify the port using the port: option")
     if not value:
@@ -27,8 +57,15 @@ def validate_broker(value):
     return value
 
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
-    cv.GenerateID(CONF_MQTT): cv.register_variable_id,
+def validate_fingerprint(value):
+    value = cv.string(value)
+    if re.match(r'^[0-9a-f]{40}$', value) is None:
+        raise vol.Invalid(u"fingerprint must be valid SHA1 hash")
+    return value
+
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(MQTTClientComponent),
     vol.Required(CONF_BROKER): validate_broker,
     vol.Optional(CONF_PORT, default=1883): cv.port,
     vol.Optional(CONF_USERNAME, default=''): cv.string,
@@ -37,19 +74,37 @@ CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
     vol.Optional(CONF_DISCOVERY): cv.boolean,
     vol.Optional(CONF_DISCOVERY_RETAIN): cv.boolean,
     vol.Optional(CONF_DISCOVERY_PREFIX): cv.publish_topic,
-    vol.Optional(CONF_BIRTH_MESSAGE): MQTT_WILL_BIRTH_SCHEMA,
-    vol.Optional(CONF_WILL_MESSAGE): MQTT_WILL_BIRTH_SCHEMA,
+    vol.Optional(CONF_BIRTH_MESSAGE): MQTT_MESSAGE_SCHEMA,
+    vol.Optional(CONF_WILL_MESSAGE): MQTT_MESSAGE_SCHEMA,
+    vol.Optional(CONF_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, default=0): cv.mqtt_qos,
+    }),
+    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,
+    }),
 })
 
 
 def exp_mqtt_message(config):
     if config is None:
-        return exp_empty_optional('mqtt::MQTTMessage')
+        return optional(TemplateArguments(MQTTMessage))
     exp = StructInitializer(
-        'mqtt::MQTTMessage',
+        MQTTMessage,
         ('topic', config[CONF_TOPIC]),
-        ('payload', config[CONF_PAYLOAD]),
+        ('payload', config.get(CONF_PAYLOAD, "")),
         ('qos', config[CONF_QOS]),
         ('retain', config[CONF_RETAIN])
     )
@@ -59,18 +114,197 @@ def exp_mqtt_message(config):
 def to_code(config):
     rhs = App.init_mqtt(config[CONF_BROKER], config[CONF_PORT],
                         config[CONF_USERNAME], config[CONF_PASSWORD])
-    mqtt = Pvariable('mqtt::MQTTClientComponent', config[CONF_ID], rhs)
+    mqtt = Pvariable(config[CONF_ID], rhs)
+
     if not config.get(CONF_DISCOVERY, True):
         add(mqtt.disable_discovery())
-    if CONF_DISCOVERY_RETAIN in config or CONF_DISCOVERY_PREFIX in config:
+    elif CONF_DISCOVERY_RETAIN in config or CONF_DISCOVERY_PREFIX in config:
         discovery_retain = config.get(CONF_DISCOVERY_RETAIN, True)
         discovery_prefix = config.get(CONF_DISCOVERY_PREFIX, 'homeassistant')
         add(mqtt.set_discovery_info(discovery_prefix, discovery_retain))
-    if CONF_BIRTH_MESSAGE in config:
-        add(mqtt.set_birth_message(config[CONF_BIRTH_MESSAGE]))
-    if CONF_WILL_MESSAGE in config:
-        add(mqtt.set_last_will(config[CONF_WILL_MESSAGE]))
     if CONF_TOPIC_PREFIX in config:
         add(mqtt.set_topic_prefix(config[CONF_TOPIC_PREFIX]))
+
+    if CONF_BIRTH_MESSAGE in config:
+        birth_message = config[CONF_BIRTH_MESSAGE]
+        if 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 config:
+                add(mqtt.set_log_level(logger.LOG_LEVELS[config[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(ArrayInitializer(*arr, multiline=False)))
+
+    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 = mqtt.make_message_trigger(conf[CONF_TOPIC], conf[CONF_QOS])
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, std_string, 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_automation(trigger, JsonObjectConstRef, conf)
+
+
+CONF_MQTT_PUBLISH = 'mqtt.publish'
+MQTT_PUBLISH_ACTION_SCHEMA = vol.Schema({
+    vol.Required(CONF_TOPIC): cv.templatable(cv.publish_topic),
+    vol.Required(CONF_PAYLOAD): cv.templatable(cv.mqtt_payload),
+    vol.Optional(CONF_QOS): cv.templatable(cv.mqtt_qos),
+    vol.Optional(CONF_RETAIN): cv.templatable(cv.boolean),
+})
+
+
+@ACTION_REGISTRY.register(CONF_MQTT_PUBLISH, MQTT_PUBLISH_ACTION_SCHEMA)
+def mqtt_publish_action_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    rhs = App.Pget_mqtt_client().Pmake_publish_action(template_arg)
+    type = MQTTPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_TOPIC], arg_type, std_string):
+        yield None
+    add(action.set_topic(template_))
+
+    for template_ in templatable(config[CONF_PAYLOAD], arg_type, std_string):
+        yield None
+    add(action.set_payload(template_))
+    if CONF_QOS in config:
+        for template_ in templatable(config[CONF_QOS], arg_type, uint8):
+            yield
+        add(action.set_qos(template_))
+    if CONF_RETAIN in config:
+        for template_ in templatable(config[CONF_RETAIN], arg_type, bool_):
+            yield None
+        add(action.set_retain(template_))
+    yield action
+
+
+CONF_MQTT_PUBLISH_JSON = 'mqtt.publish_json'
+MQTT_PUBLISH_JSON_ACTION_SCHEMA = vol.Schema({
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    rhs = App.Pget_mqtt_client().Pmake_publish_json_action(template_arg)
+    type = MQTTPublishJsonAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_TOPIC], arg_type, std_string):
+        yield None
+    add(action.set_topic(template_))
+
+    for lambda_ in process_lambda(config[CONF_PAYLOAD], [(arg_type, 'x'), (JsonObjectRef, 'root')]):
+        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 build_hass_config(data, component_type, config, include_state=True, include_command=True,
+                      platform='mqtt'):
+    if config.get(CONF_INTERNAL, False):
+        return None
+    ret = OrderedDict()
+    ret['platform'] = platform
+    ret['name'] = config[CONF_NAME]
+    if include_state:
+        default = get_default_topic_for(data, component_type, config[CONF_NAME], 'state')
+        ret['state_topic'] = config.get(CONF_STATE_TOPIC, default)
+    if include_command:
+        default = get_default_topic_for(data, component_type, config[CONF_NAME], 'command')
+        ret['command_topic'] = config.get(CONF_STATE_TOPIC, default)
+    avail = config.get(CONF_AVAILABILITY, data.availability)
+    if avail:
+        ret['availability_topic'] = avail[CONF_TOPIC]
+        payload_available = avail[CONF_PAYLOAD_AVAILABLE]
+        if payload_available != 'online':
+            ret['payload_available'] = payload_available
+        payload_not_available = avail[CONF_PAYLOAD_NOT_AVAILABLE]
+        if payload_not_available != 'offline':
+            ret['payload_not_available'] = payload_not_available
+    return ret
+
+
+class GenerateHassConfigData(object):
+    def __init__(self, config):
+        if 'mqtt' not in config:
+            raise ESPHomeYAMLError("Cannot generate Home Assistant MQTT config if MQTT is not "
+                                   "used!")
+        mqtt = config[CONF_MQTT]
+        self.topic_prefix = mqtt.get(CONF_TOPIC_PREFIX, config[CONF_ESPHOMEYAML][CONF_NAME])
+        birth_message = mqtt.get(CONF_BIRTH_MESSAGE)
+        if CONF_BIRTH_MESSAGE not in mqtt:
+            birth_message = {
+                CONF_TOPIC: self.topic_prefix + '/status',
+                CONF_PAYLOAD: 'online',
+            }
+        will_message = mqtt.get(CONF_WILL_MESSAGE)
+        if CONF_WILL_MESSAGE not in mqtt:
+            will_message = {
+                CONF_TOPIC: self.topic_prefix + '/status',
+                CONF_PAYLOAD: 'offline'
+            }
+        if not birth_message or not will_message:
+            self.availability = None
+        elif birth_message[CONF_TOPIC] != will_message[CONF_TOPIC]:
+            self.availability = None
+        else:
+            self.availability = {
+                CONF_TOPIC: birth_message[CONF_TOPIC],
+                CONF_PAYLOAD_AVAILABLE: birth_message[CONF_PAYLOAD],
+                CONF_PAYLOAD_NOT_AVAILABLE: will_message[CONF_PAYLOAD],
+            }

esphomeyaml/components/my9231.py

@@ -0,0 +1,52 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import output
+from esphomeyaml.const import (CONF_DATA_PIN, CONF_CLOCK_PIN, CONF_NUM_CHANNELS,
+                               CONF_NUM_CHIPS, CONF_BIT_DEPTH, CONF_ID,
+                               CONF_UPDATE_ON_BOOT)
+from esphomeyaml.helpers import (gpio_output_pin_expression, App, Pvariable,
+                                 add, setup_component, Component)
+
+MY9231OutputComponent = output.output_ns.class_('MY9231OutputComponent', Component)
+
+
+MY9231_SCHEMA = vol.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): vol.All(vol.Coerce(int),
+                                          cv.one_of(8, 12, 14, 16)),
+    vol.Optional(CONF_UPDATE_ON_BOOT): vol.Coerce(bool),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [MY9231_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        di = None
+        for di in gpio_output_pin_expression(conf[CONF_DATA_PIN]):
+            yield
+        dcki = None
+        for dcki in gpio_output_pin_expression(conf[CONF_CLOCK_PIN]):
+            yield
+        rhs = App.make_my9231_component(di, dcki)
+        my9231 = Pvariable(conf[CONF_ID], rhs)
+        if CONF_NUM_CHANNELS in conf:
+            add(my9231.set_num_channels(conf[CONF_NUM_CHANNELS]))
+        if CONF_NUM_CHIPS in conf:
+            add(my9231.set_num_chips(conf[CONF_NUM_CHIPS]))
+        if CONF_BIT_DEPTH in conf:
+            add(my9231.set_bit_depth(conf[CONF_BIT_DEPTH]))
+        if CONF_UPDATE_ON_BOOT in conf:
+            add(my9231.set_update(conf[CONF_UPDATE_ON_BOOT]))
+        setup_component(my9231, conf)
+
+
+BUILD_FLAGS = '-DUSE_MY9231_OUTPUT'

esphomeyaml/components/ota.py

@@ -1,20 +1,21 @@
-import hashlib
 import logging
 
 import voluptuous as vol
 
+from esphomeyaml import core
 import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_ID, CONF_OTA, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE, \
-    ESP_PLATFORM_ESP8266, ESP_PLATFORM_ESP32
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, add
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, Component
 
 _LOGGER = logging.getLogger(__name__)
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
-    cv.GenerateID(CONF_OTA): cv.register_variable_id,
+OTAComponent = esphomelib_ns.class_('OTAComponent', Component)
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(OTAComponent),
     vol.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
-    # TODO Num attempts + wait time
     vol.Optional(CONF_PORT): cv.port,
     vol.Optional(CONF_PASSWORD): cv.string,
 })
@@ -22,10 +23,11 @@ CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
 
 def to_code(config):
     rhs = App.init_ota()
-    ota = Pvariable('OTAComponent', config[CONF_ID], rhs)
+    ota = Pvariable(config[CONF_ID], rhs)
     if CONF_PASSWORD in config:
-        h = hashlib.md5(config[CONF_PASSWORD].encode()).hexdigest()
-        add(ota.set_auth_password_hash(h))
+        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())
 
@@ -33,12 +35,22 @@ def to_code(config):
 def get_port(config):
     if CONF_PORT in config[CONF_OTA]:
         return config[CONF_OTA][CONF_PORT]
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         return 3232
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         return 8266
     raise ESPHomeYAMLError(u"Invalid ESP Platform for ESP OTA port.")
 
 
 def get_auth(config):
     return config[CONF_OTA].get(CONF_PASSWORD, '')
+
+
+BUILD_FLAGS = '-DUSE_OTA'
+REQUIRED_BUILD_FLAGS = '-DUSE_NEW_OTA'
+
+
+def lib_deps(config):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return ['ArduinoOTA', 'Update', 'ESPmDNS']
+    return ['Hash', 'ESP8266mDNS', 'ArduinoOTA']

esphomeyaml/components/output/__init__.py

@@ -1,25 +1,106 @@
-
 import voluptuous as vol
 
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_POWER_SUPPLY, CONF_INVERTED, CONF_MAX_POWER
-from esphomeyaml.helpers import get_variable, add
+from esphomeyaml.components.power_supply import PowerSupplyComponent
+from esphomeyaml.const import CONF_INVERTED, CONF_MAX_POWER, CONF_POWER_SUPPLY, CONF_ID, CONF_LEVEL
+from esphomeyaml.helpers import add, esphomelib_ns, get_variable, TemplateArguments, Pvariable, \
+    templatable, float_, add_job, Action
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_POWER_SUPPLY): cv.variable_id,
-    vol.Optional(CONF_INVERTED): cv.boolean,
-}).extend(cv.REQUIRED_ID_SCHEMA.schema)
 
-FLOAT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_MAX_POWER): cv.zero_to_one_float,
 })
 
+BINARY_OUTPUT_SCHEMA = vol.Schema({
+    vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
+    vol.Optional(CONF_INVERTED): cv.boolean,
+})
 
-def setup_output_platform(obj, config, skip_power_supply=False):
+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,
+})
+
+FLOAT_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FLOAT_OUTPUT_SCHEMA.schema)
+
+output_ns = esphomelib_ns.namespace('output')
+BinaryOutput = output_ns.class_('BinaryOutput')
+FloatOutput = output_ns.class_('FloatOutput', BinaryOutput)
+
+# 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 = get_variable(config[CONF_POWER_SUPPLY])
+        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]))
+
+
+def setup_output_platform(obj, config, skip_power_supply=False):
+    add_job(setup_output_platform_, obj, config, skip_power_supply)
+
+
+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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(arg_type)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_OUTPUT_SET_LEVEL = 'output.set_level'
+OUTPUT_SET_LEVEL_ACTION = vol.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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_set_level_action(template_arg)
+    type = SetLevelAction.template(arg_type)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_LEVEL], arg_type, float_):
+        yield None
+    add(action.set_level(template_))
+    yield action

esphomeyaml/components/output/esp8266_pwm.py

@@ -2,23 +2,40 @@ import voluptuous as vol
 
 from esphomeyaml import pins
 from esphomeyaml.components import output
-from esphomeyaml.const import CONF_ID, CONF_PIN, \
-    ESP_PLATFORM_ESP8266
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin, get_gpio_pin_number
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_PIN, ESP_PLATFORM_ESP8266, CONF_FREQUENCY
+from esphomeyaml.helpers import App, Component, Pvariable, gpio_output_pin_expression, \
+    setup_component, add
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
 
-PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-})
+
+def valid_pwm_pin(value):
+    num = value[CONF_NUMBER]
+    cv.one_of(0, 1, 2, 3, 4, 5, 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):
-    if get_gpio_pin_number(config[CONF_PIN]) >= 16:
-        # Too difficult to do in config validation
-        raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
     rhs = App.make_esp8266_pwm_output(pin)
-    gpio = Pvariable('output::ESP8266PWMOutput', config[CONF_ID], rhs)
+    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'

esphomeyaml/components/output/gpio.py

@@ -1,17 +1,28 @@
 import voluptuous as vol
 
 from esphomeyaml import pins
+import esphomeyaml.config_validation as cv
 from esphomeyaml.components import output
 from esphomeyaml.const import CONF_ID, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression, setup_component, \
+    Component
 
-PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-})
+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):
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
     rhs = App.make_gpio_output(pin)
-    gpio = Pvariable('output::GPIOBinaryOutputComponent', config[CONF_ID], rhs)
+    gpio = Pvariable(config[CONF_ID], rhs)
     output.setup_output_platform(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_OUTPUT'

esphomeyaml/components/output/ledc.py

@@ -5,7 +5,7 @@ from esphomeyaml import pins
 from esphomeyaml.components import output
 from esphomeyaml.const import APB_CLOCK_FREQ, CONF_BIT_DEPTH, CONF_CHANNEL, CONF_FREQUENCY, \
     CONF_ID, CONF_PIN, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Pvariable, add
+from esphomeyaml.helpers import App, Pvariable, add, setup_component, Component
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -15,16 +15,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,7 +35,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'

esphomeyaml/components/output/my9231.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import output
+from esphomeyaml.components.my9231 import MY9231OutputComponent
+from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_MY9231_ID, CONF_POWER_SUPPLY
+from esphomeyaml.helpers import Pvariable, get_variable, 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'

esphomeyaml/components/output/pca9685.py

@@ -2,24 +2,32 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import output
-from esphomeyaml.components.pca9685 import PCA9685_COMPONENT_TYPE
+from esphomeyaml.components.pca9685 import PCA9685OutputComponent
 from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY
 from esphomeyaml.helpers import Pvariable, get_variable
 
 DEPENDENCIES = ['pca9685']
 
-PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
+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)),
-    vol.Optional(CONF_PCA9685_ID): cv.variable_id,
+    cv.GenerateID(CONF_PCA9685_ID): cv.use_variable_id(PCA9685OutputComponent),
 })
 
 
 def to_code(config):
     power_supply = None
     if CONF_POWER_SUPPLY in config:
-        power_supply = get_variable(config[CONF_POWER_SUPPLY])
-    pca9685 = get_variable(config.get(CONF_PCA9685_ID), PCA9685_COMPONENT_TYPE)
+        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('output::PCA9685OutputComponent::Channel', config[CONF_ID], rhs)
+    out = Pvariable(config[CONF_ID], rhs)
     output.setup_output_platform(out, config, skip_power_supply=True)
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphomeyaml/components/pca9685.py

@@ -1,22 +1,26 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import output, i2c
 from esphomeyaml.const import CONF_ADDRESS, CONF_FREQUENCY, CONF_ID, CONF_PHASE_BALANCER
-from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, RawExpression, add
+from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, add, setup_component, Component
 
 DEPENDENCIES = ['i2c']
 
-PHASE_BALANCERS = ['None', 'Linear', 'Weaved']
+PCA9685OutputComponent = output.output_ns.class_('PCA9685OutputComponent',
+                                                 Component, i2c.I2CDevice)
 
-PCA9685_COMPONENT_TYPE = 'output::PCA9685OutputComponent'
+PHASE_BALANCER_MESSAGE = ("The phase_balancer option has been removed in version 1.5.0. "
+                          "esphomelib will now automatically choose a suitable phase balancer.")
 
 PCA9685_SCHEMA = vol.Schema({
-    cv.GenerateID('pca9685'): cv.register_variable_id,
+    cv.GenerateID(): cv.declare_variable_id(PCA9685OutputComponent),
     vol.Required(CONF_FREQUENCY): vol.All(cv.frequency,
-                                          vol.Range(min=24, max=1526)),
-    vol.Optional(CONF_PHASE_BALANCER): vol.All(vol.Title, vol.Any(*PHASE_BALANCERS)),
+                                          vol.Range(min=23.84, max=1525.88)),
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
-})
+
+    vol.Optional(CONF_PHASE_BALANCER): cv.invalid(PHASE_BALANCER_MESSAGE),
+}).extend(cv.COMPONENT_SCHEMA.schema)
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCA9685_SCHEMA])
 
@@ -24,10 +28,10 @@ CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCA9685_SCHEMA])
 def to_code(config):
     for conf in config:
         rhs = App.make_pca9685_component(conf.get(CONF_FREQUENCY))
-        pca9685 = Pvariable(PCA9685_COMPONENT_TYPE, conf[CONF_ID], rhs)
+        pca9685 = Pvariable(conf[CONF_ID], rhs)
         if CONF_ADDRESS in conf:
             add(pca9685.set_address(HexIntLiteral(conf[CONF_ADDRESS])))
-        if CONF_PHASE_BALANCER in conf:
-            phase_balancer = RawExpression(u'PCA9685_PhaseBalancer_{}'.format(
-                conf[CONF_PHASE_BALANCER]))
-            add(pca9685.set_phase_balancer(phase_balancer))
+        setup_component(pca9685, conf)
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphomeyaml/components/pcf8574.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphomeyaml import pins
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_PCF8575
+from esphomeyaml.helpers import App, GPIOInputPin, GPIOOutputPin, Pvariable, io_ns, setup_component
+
+DEPENDENCIES = ['i2c']
+
+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)
+
+PCF8574_SCHEMA = vol.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)
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCF8574_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        rhs = App.make_pcf8574_component(conf[CONF_ADDRESS], conf[CONF_PCF8575])
+        var = Pvariable(conf[CONF_ID], rhs)
+        setup_component(var, conf)
+
+
+BUILD_FLAGS = '-DUSE_PCF8574'

esphomeyaml/components/pn532.py

@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins, automation
+from esphomeyaml.components import binary_sensor, spi
+from esphomeyaml.components.spi import SPIComponent
+from esphomeyaml.const import CONF_CS_PIN, CONF_ID, CONF_SPI_ID, CONF_UPDATE_INTERVAL, \
+    CONF_ON_TAG, CONF_TRIGGER_ID
+from esphomeyaml.helpers import App, Pvariable, get_variable, gpio_output_pin_expression, \
+    std_string, setup_component, PollingComponent, Trigger
+
+DEPENDENCIES = ['spi']
+
+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 = vol.All(cv.ensure_list, [vol.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 conf in config:
+        for spi_ in get_variable(conf[CONF_SPI_ID]):
+            yield
+        for cs in gpio_output_pin_expression(conf[CONF_CS_PIN]):
+            yield
+        rhs = App.make_pn532_component(spi_, cs, conf.get(CONF_UPDATE_INTERVAL))
+        pn532 = Pvariable(conf[CONF_ID], rhs)
+
+        for conf_ in conf.get(CONF_ON_TAG, []):
+            trigger = Pvariable(conf_[CONF_TRIGGER_ID], pn532.make_trigger())
+            automation.build_automation(trigger, std_string, conf_)
+
+        setup_component(pn532, conf)
+
+
+BUILD_FLAGS = '-DUSE_PN532'

esphomeyaml/components/power_supply.py

@@ -3,23 +3,34 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, add, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, gpio_output_pin_expression, \
+    setup_component, Component
 
-POWER_SUPPLY_SCHEMA = cv.REQUIRED_ID_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period,
-    vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period,
-})
+PowerSupplyComponent = esphomelib_ns.class_('PowerSupplyComponent', Component)
+
+POWER_SUPPLY_SCHEMA = vol.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)
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [POWER_SUPPLY_SCHEMA])
 
 
 def to_code(config):
     for conf in config:
-        pin = exp_gpio_output_pin(conf[CONF_PIN])
+        for pin in gpio_output_pin_expression(conf[CONF_PIN]):
+            yield
+
         rhs = App.make_power_supply(pin)
-        psu = Pvariable('PowerSupplyComponent', conf[CONF_ID], rhs)
+        psu = Pvariable(conf[CONF_ID], rhs)
         if CONF_ENABLE_TIME in conf:
             add(psu.set_enable_time(conf[CONF_ENABLE_TIME]))
         if CONF_KEEP_ON_TIME in conf:
             add(psu.set_keep_on_time(conf[CONF_KEEP_ON_TIME]))
+
+        setup_component(psu, conf)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'

esphomeyaml/components/rdm6300.py

@@ -0,0 +1,28 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor, uart
+from esphomeyaml.const import CONF_ID, CONF_UART_ID
+from esphomeyaml.helpers import App, Pvariable, get_variable, setup_component, Component
+
+DEPENDENCIES = ['uart']
+
+RDM6300Component = binary_sensor.binary_sensor_ns.class_('RDM6300Component', Component,
+                                                         uart.UARTDevice)
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list_not_empty, [vol.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 conf in config:
+        for uart_ in get_variable(conf[CONF_UART_ID]):
+            yield
+        rhs = App.make_rdm6300_component(uart_)
+        var = Pvariable(conf[CONF_ID], rhs)
+        setup_component(var, conf)
+
+
+BUILD_FLAGS = '-DUSE_RDM6300'

esphomeyaml/components/remote_receiver.py

@@ -0,0 +1,72 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_BUFFER_SIZE, CONF_DUMP, CONF_FILTER, CONF_ID, CONF_IDLE, \
+    CONF_PIN, CONF_TOLERANCE
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, gpio_input_pin_expression, \
+    setup_component, Component
+
+remote_ns = esphomelib_ns.namespace('remote')
+
+RemoteControlComponentBase = remote_ns.class_('RemoteControlComponentBase')
+RemoteReceiverComponent = remote_ns.class_('RemoteReceiverComponent',
+                                           RemoteControlComponentBase,
+                                           Component)
+
+RemoteReceiveDumper = remote_ns.class_('RemoteReceiveDumper')
+
+DUMPERS = {
+    '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),
+}
+
+
+def validate_dumpers_all(value):
+    if not isinstance(value, (str, unicode)):
+        raise vol.Invalid("Not valid dumpers")
+    if value.upper() == "ALL":
+        return list(sorted(list(DUMPERS)))
+    raise vol.Invalid("Not valid dumpers")
+
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(RemoteReceiverComponent),
+    vol.Required(CONF_PIN): pins.gpio_input_pin_schema,
+    vol.Optional(CONF_DUMP, default=[]):
+        vol.Any(validate_dumpers_all,
+                vol.All(cv.ensure_list, [vol.All(vol.Lower, cv.one_of(*DUMPERS))])),
+    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 conf in config:
+        for pin in gpio_input_pin_expression(conf[CONF_PIN]):
+            yield
+        rhs = App.make_remote_receiver_component(pin)
+        receiver = Pvariable(conf[CONF_ID], rhs)
+
+        for dumper in conf[CONF_DUMP]:
+            add(receiver.add_dumper(DUMPERS[dumper].new()))
+        if CONF_TOLERANCE in conf:
+            add(receiver.set_tolerance(conf[CONF_TOLERANCE]))
+        if CONF_BUFFER_SIZE in conf:
+            add(receiver.set_buffer_size(conf[CONF_BUFFER_SIZE]))
+        if CONF_FILTER in conf:
+            add(receiver.set_filter_us(conf[CONF_FILTER]))
+        if CONF_IDLE in conf:
+            add(receiver.set_idle_us(conf[CONF_IDLE]))
+
+        setup_component(receiver, conf)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_RECEIVER'

esphomeyaml/components/remote_transmitter.py

@@ -0,0 +1,119 @@
+import voluptuous as vol
+
+from esphomeyaml import pins
+from esphomeyaml.components.remote_receiver import RemoteControlComponentBase, remote_ns
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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 esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, Component, Pvariable, add, gpio_output_pin_expression, \
+    setup_component
+
+RemoteTransmitterComponent = remote_ns.class_('RemoteTransmitterComponent',
+                                              RemoteControlComponentBase, Component)
+RCSwitchProtocol = remote_ns.class_('RCSwitchProtocol')
+rc_switch_protocols = remote_ns.rc_switch_protocols
+
+
+def validate_rc_switch_code(value):
+    if not isinstance(value, (str, unicode)):
+        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)),
+    vol.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 = vol.Schema({
+    vol.Required(CONF_CODE): validate_rc_switch_code,
+    vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
+})
+RC_SWITCH_TYPE_A_SCHEMA = vol.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 = vol.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 = vol.Schema({
+    vol.Required(CONF_FAMILY): vol.All(
+        cv.string, vol.Lower,
+        cv.one_of('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+                  'p')),
+    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 = vol.Schema({
+    vol.Required(CONF_GROUP): vol.All(cv.string, vol.Lower, cv.one_of('a', 'b', 'c', 'd')),
+    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 = vol.All(cv.ensure_list, [vol.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 conf in config:
+        for pin in gpio_output_pin_expression(conf[CONF_PIN]):
+            yield
+        rhs = App.make_remote_transmitter_component(pin)
+        transmitter = Pvariable(conf[CONF_ID], rhs)
+
+        if CONF_CARRIER_DUTY_PERCENT in conf:
+            add(transmitter.set_carrier_duty_percent(conf[CONF_CARRIER_DUTY_PERCENT]))
+
+        setup_component(transmitter, conf)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_TRANSMITTER'

esphomeyaml/components/script.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+from esphomeyaml import automation
+from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ID
+from esphomeyaml.helpers import NoArg, Pvariable, TemplateArguments, esphomelib_ns, get_variable, \
+    Trigger, Action
+
+Script = esphomelib_ns.class_('Script', Trigger.template(NoArg))
+ScriptExecuteAction = esphomelib_ns.class_('ScriptExecuteAction', 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_automation(trigger, NoArg, 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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_execute_action(template_arg)
+    type = ScriptExecuteAction.template(arg_type)
+    yield Pvariable(action_id, rhs, type=type)

esphomeyaml/components/sensor/__init__.py

@@ -1,100 +1,237 @@
 import voluptuous as vol
 
+from esphomeyaml import automation
+from esphomeyaml.components import mqtt
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_EXPIRE_AFTER, \
-    CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_ICON, \
-    CONF_ID, CONF_LAMBDA, CONF_MULTIPLY, CONF_NAME, CONF_OFFSET, CONF_SEND_EVERY, \
-    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
-from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
-    setup_mqtt_component
+from esphomeyaml.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
+    CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, \
+    CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_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_TRIGGER_ID, CONF_UNIQUE, \
+    CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
+from esphomeyaml.helpers import App, ArrayInitializer, Component, Nameable, PollingComponent, \
+    Pvariable, Trigger, add, add_job, esphomelib_ns, float_, process_lambda, setup_mqtt_component, \
+    templatable
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.Any(
-    # TODO Fix weird voluptuous error messages
-    vol.Schema({vol.Required(CONF_OFFSET): vol.Coerce(float)}),
-    vol.Schema({vol.Required(CONF_MULTIPLY): vol.Coerce(float)}),
-    vol.Schema({vol.Required(CONF_FILTER_OUT): vol.Coerce(float)}),
-    vol.Schema({vol.Required(CONF_FILTER_NAN): None}),
-    vol.Schema({
-        vol.Required(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.Schema({
-            vol.Required(CONF_WINDOW_SIZE): cv.positive_not_null_int,
-            vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
-        })
-    }),
-    vol.Schema({
-        vol.Required(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
-            vol.Required(CONF_ALPHA): cv.positive_float,
-            vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
-        })
-    }),
-    vol.Schema({vol.Required(CONF_LAMBDA): cv.string_strict}),
-)])
 
-MQTT_SENSOR_SCHEMA = vol.Schema({
-    vol.Required(CONF_NAME): cv.string,
+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_FILTER_NAN,
+               CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_LAMBDA,
+               CONF_THROTTLE, CONF_DELTA, CONF_UNIQUE, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR]
+
+FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
+    vol.Optional(CONF_OFFSET): vol.Coerce(float),
+    vol.Optional(CONF_MULTIPLY): vol.Coerce(float),
+    vol.Optional(CONF_FILTER_OUT): vol.Coerce(float),
+    vol.Optional(CONF_FILTER_NAN): None,
+    vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.All(vol.Schema({
+        vol.Required(CONF_WINDOW_SIZE): cv.positive_not_null_int,
+        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+        vol.Optional(CONF_SEND_FIRST_AT): cv.positive_not_null_int,
+    }), validate_send_first_at),
+    vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
+        vol.Required(CONF_ALPHA): cv.positive_float,
+        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+    }),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_THROTTLE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DELTA): vol.Coerce(float),
+    vol.Optional(CONF_UNIQUE): None,
+    vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DEBOUNCE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_OR): validate_recursive_filter,
+}, cv.has_exactly_one_key(*FILTER_KEYS))])
+
+# Base
+sensor_ns = esphomelib_ns.namespace('sensor')
+Sensor = sensor_ns.class_('Sensor', Nameable)
+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_))
+
+# 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)
+FilterOutNANFilter = sensor_ns.class_('FilterOutNANFilter', 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)
+UniqueFilter = sensor_ns.class_('UniqueFilter', 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.Any(None, cv.positive_time_period),
-    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA
+    vol.Optional(CONF_EXPIRE_AFTER): 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): vol.Coerce(float),
+        vol.Optional(CONF_BELOW): vol.Coerce(float),
+    }, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
 })
 
-MQTT_SENSOR_ID_SCHEMA = MQTT_SENSOR_SCHEMA.extend({
-    cv.GenerateID('mqtt_sensor'): cv.register_variable_id,
-})
-
-OffsetFilter = MockObj('new sensor::OffsetFilter')
-MultiplyFilter = MockObj('new sensor::MultiplyFilter')
-FilterOutValueFilter = MockObj('new sensor::FilterOutValueFilter')
-FilterOutNANFilter = MockObj('new sensor::FilterOutNANFilter')
-SlidingWindowMovingAverageFilter = MockObj('new sensor::SlidingWindowMovingAverageFilter')
-ExponentialMovingAverageFilter = MockObj('new sensor::ExponentialMovingAverageFilter')
-LambdaFilter = MockObj('new sensor::LambdaFilter')
+SENSOR_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SENSOR_SCHEMA.schema)
 
 
 def setup_filter(config):
     if CONF_OFFSET in config:
-        return OffsetFilter(config[CONF_OFFSET])
-    if CONF_MULTIPLY in config:
-        return MultiplyFilter(config[CONF_MULTIPLY])
-    if CONF_FILTER_OUT in config:
-        return FilterOutValueFilter(config[CONF_FILTER_OUT])
-    if CONF_FILTER_NAN in config:
-        return FilterOutNANFilter()
-    if CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
+        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_FILTER_NAN in config:
+        yield FilterOutNANFilter.new()
+    elif CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
         conf = config[CONF_SLIDING_WINDOW_MOVING_AVERAGE]
-        return SlidingWindowMovingAverageFilter(conf[CONF_WINDOW_SIZE], conf[CONF_SEND_EVERY])
-    if CONF_EXPONENTIAL_MOVING_AVERAGE in config:
+        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]
-        return ExponentialMovingAverageFilter(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
-    if CONF_LAMBDA in config:
-        s = '[](float x) -> Optional<float> {{ return {}; }}'.format(config[CONF_LAMBDA])
-        return LambdaFilter(RawExpression(s))
-    raise ValueError("Filter unsupported: {}".format(config))
+        yield ExponentialMovingAverageFilter.new(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
+    elif CONF_LAMBDA in config:
+        lambda_ = None
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(float_, 'x')]):
+            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:
+        filters = None
+        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_UNIQUE in config:
+        yield UniqueFilter.new()
 
 
-def setup_mqtt_sensor_component(obj, config):
+def setup_filters(config):
+    filters = []
+    for conf in config:
+        filter = None
+        for filter in setup_filter(conf):
+            yield None
+        filters.append(filter)
+    yield ArrayInitializer(*filters)
+
+
+def setup_sensor_core_(sensor_var, mqtt_var, config):
+    if CONF_INTERNAL in config:
+        add(sensor_var.set_internal(config[CONF_INTERNAL]))
     if CONF_UNIT_OF_MEASUREMENT in config:
-        add(obj.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+        add(sensor_var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
     if CONF_ICON in config:
-        add(obj.set_icon(config[CONF_ICON]))
+        add(sensor_var.set_icon(config[CONF_ICON]))
     if CONF_ACCURACY_DECIMALS in config:
-        add(obj.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+        add(sensor_var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_FILTERS in config:
+        filters = None
+        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_automation(trigger, float_, 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_automation(trigger, float_, conf)
+    for conf in config.get(CONF_ON_VALUE_RANGE, []):
+        rhs = sensor_var.make_value_range_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        if CONF_ABOVE in conf:
+            template_ = None
+            for template_ in templatable(conf[CONF_ABOVE], float_, float_):
+                yield
+            add(trigger.set_min(template_))
+        if CONF_BELOW in conf:
+            template_ = None
+            for template_ in templatable(conf[CONF_BELOW], float_, float_):
+                yield
+            add(trigger.set_max(template_))
+        automation.build_automation(trigger, float_, conf)
+
     if CONF_EXPIRE_AFTER in config:
         if config[CONF_EXPIRE_AFTER] is None:
-            add(obj.disable_expire_after())
+            add(mqtt_var.disable_expire_after())
         else:
-            add(obj.set_expire_after(config[CONF_EXPIRE_AFTER]))
-    if CONF_FILTERS in config:
-        filters = [setup_filter(x) for x in config[CONF_FILTERS]]
-        add(obj.set_filters(ArrayInitializer(*filters)))
-    setup_mqtt_component(obj, config)
+            add(mqtt_var.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    setup_mqtt_component(mqtt_var, config)
 
 
-def make_mqtt_sensor_for(exp, config):
-    rhs = App.make_mqtt_sensor_for(exp, config[CONF_NAME])
-    mqtt_sensor = Pvariable('sensor::MQTTSensorComponent', config[CONF_ID], rhs)
-    setup_mqtt_sensor_component(mqtt_sensor, config)
+def setup_sensor(sensor_obj, mqtt_obj, config):
+    sensor_var = Pvariable(config[CONF_ID], sensor_obj, has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    add_job(setup_sensor_core_, sensor_var, mqtt_var, config)
+
+
+def register_sensor(var, config):
+    sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    rhs = App.register_sensor(sensor_var)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], rhs, has_side_effects=True)
+    add_job(setup_sensor_core_, sensor_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SENSOR'
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'sensor', config, include_state=True, include_command=False)
+    if ret is None:
+        return None
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        ret['unit_of_measurement'] = config[CONF_UNIT_OF_MEASUREMENT]
+    if CONF_EXPIRE_AFTER in config:
+        expire = config[CONF_EXPIRE_AFTER]
+        if expire is not None:
+            ret['expire_after'] = expire.total_seconds
+    if CONF_ICON in config:
+        ret['icon'] = config[CONF_ICON]
+    return ret

esphomeyaml/components/sensor/adc.py

@@ -3,33 +3,59 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, \
+from esphomeyaml.const import CONF_ATTENUATION, CONF_MAKE_ID, CONF_NAME, CONF_PIN, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, RawExpression, add, variable
+from esphomeyaml.helpers import App, Application, add, global_ns, variable, setup_component
 
 ATTENUATION_MODES = {
-    '0db': 'ADC_0db',
-    '2.5db': 'ADC_2_5db',
-    '6db': 'ADC_6db',
-    '11db': 'ADC_11db',
+    '0db': global_ns.ADC_0db,
+    '2.5db': global_ns.ADC_2_5db,
+    '6db': global_ns.ADC_6db,
+    '11db': global_ns.ADC_11db,
 }
 
-ATTENUATION_MODE_SCHEMA = vol.Any(*list(ATTENUATION_MODES.keys()))
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('adc'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.analog_pin,
-    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, ATTENUATION_MODE_SCHEMA),
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+def validate_adc_pin(value):
+    vcc = str(value).upper()
+    if vcc == 'VCC':
+        return cv.only_on_esp8266(vcc)
+    return pins.analog_pin(value)
+
+
+MakeADCSensor = Application.struct('MakeADCSensor')
+ADCSensorComponent = sensor.sensor_ns.class_('ADCSensorComponent', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ADCSensorComponent),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeADCSensor),
+    vol.Required(CONF_PIN): validate_adc_pin,
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
 
 
 def to_code(config):
-    rhs = App.make_adc_sensor(config[CONF_PIN], config[CONF_NAME],
+    pin = config[CONF_PIN]
+    if pin == 'VCC':
+        pin = 0
+    rhs = App.make_adc_sensor(config[CONF_NAME], pin,
                               config.get(CONF_UPDATE_INTERVAL))
-    make = variable('Application::MakeADCSensor', config[CONF_ID], rhs)
+    make = variable(config[CONF_MAKE_ID], rhs)
     adc = make.Padc
     if CONF_ATTENUATION in config:
-        attenuation = ATTENUATION_MODES[config[CONF_ATTENUATION]]
-        add(adc.set_attenuation(RawExpression(attenuation)))
-    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)
+        add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
+    sensor.setup_sensor(adc, make.Pmqtt, 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 to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/ads1115.py

@@ -2,29 +2,33 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import get_variable, RawExpression
+from esphomeyaml.components.ads1115 import ADS1115Component
+from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import get_variable
 
 DEPENDENCIES = ['ads1115']
 
+ADS1115Multiplexer = sensor.sensor_ns.enum('ADS1115Multiplexer')
 MUX = {
-    'A0_A1': 'ADS1115_MUX_P0_N1',
-    'A0_A3': 'ADS1115_MUX_P0_N3',
-    'A1_A3': 'ADS1115_MUX_P1_N3',
-    'A2_A3': 'ADS1115_MUX_P2_N3',
-    'A0_GND': 'ADS1115_MUX_P0_NG',
-    'A1_GND': 'ADS1115_MUX_P1_NG',
-    'A2_GND': 'ADS1115_MUX_P2_NG',
-    'A3_GND': 'ADS1115_MUX_P3_NG',
+    'A0_A1': 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': 'ADS1115_PGA_6P144',
-    '4.096': 'ADS1115_PGA_6P096',
-    '2.048': 'ADS1115_PGA_2P048',
-    '1.024': 'ADS1115_PGA_1P024',
-    '0.512': 'ADS1115_PGA_0P512',
-    '0.256': 'ADS1115_PGA_0P256',
+    '6.144': ADS1115Gain.ADS1115_GAIN_6P144,
+    '4.096': ADS1115Gain.ADS1115_GAIN_6P096,
+    '2.048': ADS1115Gain.ADS1115_GAIN_2P048,
+    '1.024': ADS1115Gain.ADS1115_GAIN_1P024,
+    '0.512': ADS1115Gain.ADS1115_GAIN_0P512,
+    '0.256': ADS1115Gain.ADS1115_GAIN_0P256,
 }
 
 
@@ -34,23 +38,39 @@ def validate_gain(value):
     elif not isinstance(value, (str, unicode)):
         raise vol.Invalid('invalid gain "{}"'.format(value))
 
-    if value not in GAIN:
-        raise vol.Invalid("Invalid gain, options are {}".format(', '.join(GAIN.keys())))
-    return value
+    return cv.one_of(*GAIN)(value)
 
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_MULTIPLEXER): vol.All(vol.Upper, vol.Any(*list(MUX.keys()))),
+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,
-    vol.Optional(CONF_ADS1115_ID): cv.variable_id,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-}).extend(sensor.MQTT_SENSOR_ID_SCHEMA.schema)
+    cv.GenerateID(CONF_ADS1115_ID): cv.use_variable_id(ADS1115Component),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}))
 
 
 def to_code(config):
-    hub = get_variable(config.get(CONF_ADS1115_ID), u'sensor::ADS1115Component')
+    hub = None
+    for hub in get_variable(config[CONF_ADS1115_ID]):
+        yield
 
-    mux = RawExpression(MUX[config[CONF_MULTIPLEXER]])
-    gain = RawExpression(GAIN[config[CONF_GAIN]])
-    sensor_ = hub.get_sensor(mux, gain, config.get(CONF_UPDATE_INTERVAL))
-    sensor.make_mqtt_sensor_for(sensor_, config)
+    mux = MUX[config[CONF_MULTIPLEXER]]
+    gain = GAIN[config[CONF_GAIN]]
+    rhs = hub.get_sensor(config[CONF_NAME], mux, gain, config.get(CONF_UPDATE_INTERVAL))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/bh1750.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor, i2c
+from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable, setup_component
+
+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,
+}
+
+MakeBH1750Sensor = Application.struct('MakeBH1750Sensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBH1750Sensor),
+    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))
+    make_bh1750 = variable(config[CONF_MAKE_ID], rhs)
+    bh1750 = make_bh1750.Pbh1750
+    if CONF_RESOLUTION in config:
+        add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
+    sensor.setup_sensor(bh1750, make_bh1750.Pmqtt, config)
+    setup_component(bh1750, config)
+
+
+BUILD_FLAGS = '-DUSE_BH1750'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/ble_rssi.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+from esphomeyaml.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphomeyaml.helpers import get_variable, esphomelib_ns
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+ESP32BLERSSISensor = esphomelib_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)
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/bme280.py

@@ -0,0 +1,95 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_IIR_FILTER, CONF_MAKE_ID, \
+    CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable, setup_component
+
+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): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+MakeBME280Sensor = Application.struct('MakeBME280Sensor')
+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(CONF_MAKE_ID): cv.declare_variable_id(MakeBME280Sensor),
+    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): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    bme280 = make.Pbme280
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bme280.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bme280.set_pressure_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_HUMIDITY]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_HUMIDITY][CONF_OVERSAMPLING]]
+        add(bme280.set_humidity_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bme280.set_iir_filter(constant))
+
+    sensor.setup_sensor(bme280.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme280.Pget_pressure_sensor(), make.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    sensor.setup_sensor(bme280.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    setup_component(bme280, config)
+
+
+BUILD_FLAGS = '-DUSE_BME280'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphomeyaml/components/sensor/bme680.py

@@ -0,0 +1,120 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import core
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_GAS_RESISTANCE, CONF_HUMIDITY, CONF_IIR_FILTER, \
+    CONF_MAKE_ID, CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL, CONF_HEATER, CONF_DURATION
+from esphomeyaml.helpers import App, Application, add, variable, setup_component
+
+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): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+MakeBME680Sensor = Application.struct('MakeBME680Sensor')
+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(CONF_MAKE_ID): cv.declare_variable_id(MakeBME680Sensor),
+    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): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    vol.Optional(CONF_HEATER): vol.Any(None, vol.All(vol.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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    bme680 = make.Pbme680
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bme680.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bme680.set_pressure_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_HUMIDITY]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_HUMIDITY][CONF_OVERSAMPLING]]
+        add(bme680.set_humidity_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bme680.set_iir_filter(constant))
+    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(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme680.Pget_pressure_sensor(), make.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    sensor.setup_sensor(bme680.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(bme680.Pget_gas_resistance_sensor(), make.Pmqtt_gas_resistance,
+                        config[CONF_GAS_RESISTANCE])
+    setup_component(bme680, config)
+
+
+BUILD_FLAGS = '-DUSE_BME680'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY]),
+            sensor.core_to_hass_config(data, config[CONF_GAS_RESISTANCE])]

esphomeyaml/components/sensor/bmp085.py

@@ -2,28 +2,49 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import sensor
-from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, \
-    CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, HexIntLiteral, add, variable
+from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, HexIntLiteral, add, variable, setup_component
 
 DEPENDENCIES = ['i2c']
 
+MakeBMP085Sensor = Application.struct('MakeBMP085Sensor')
+BMP085TemperatureSensor = sensor.sensor_ns.class_('BMP085TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BMP085PressureSensor = sensor.sensor_ns.class_('BMP085PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('bmp085_sensor'): cv.register_variable_id,
-    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
-    vol.Required(CONF_PRESSURE): MQTT_SENSOR_SCHEMA,
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBMP085Sensor),
+    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.positive_not_null_time_period,
-})
+    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 = variable('Application::MakeBMP085Component', config[CONF_ID], rhs)
+    bmp = variable(config[CONF_MAKE_ID], rhs)
     if CONF_ADDRESS in config:
         add(bmp.Pbmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
-    sensor.setup_mqtt_sensor_component(bmp.Pmqtt_temperature, config[CONF_TEMPERATURE])
-    sensor.setup_mqtt_sensor_component(bmp.Pmqtt_pressure, config[CONF_PRESSURE])
+
+    sensor.setup_sensor(bmp.Pbmp.Pget_temperature_sensor(), bmp.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp.Pbmp.Pget_pressure_sensor(), bmp.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    setup_component(bmp.Pbmp, config)
+
+
+BUILD_FLAGS = '-DUSE_BMP085_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]

esphomeyaml/components/sensor/bmp280.py

@@ -0,0 +1,83 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_IIR_FILTER, CONF_MAKE_ID, \
+    CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable, setup_component
+
+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): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+MakeBMP280Sensor = Application.struct('MakeBMP280Sensor')
+BMP280TemperatureSensor = sensor.sensor_ns.class_('BMP280TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BMP280PressureSensor = sensor.sensor_ns.class_('BMP280PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBMP280Sensor),
+    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): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    bmp280 = make.Pbmp280
+    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(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp280.Pget_pressure_sensor(), make.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    setup_component(bmp280, config)
+
+
+BUILD_FLAGS = '-DUSE_BMP280'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]

esphomeyaml/components/sensor/cse7766.py

@@ -0,0 +1,65 @@
+import voluptuous as vol
+
+from esphomeyaml.components import sensor, uart
+from esphomeyaml.components.uart import UARTComponent
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_CURRENT, CONF_ID, CONF_NAME, CONF_POWER, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL, CONF_VOLTAGE
+from esphomeyaml.helpers import App, PollingComponent, Pvariable, get_variable, setup_component
+
+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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_VOLTAGE, CONF_CURRENT, CONF_POWER):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/dallas.py

@@ -2,30 +2,37 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import sensor
-from esphomeyaml.components.dallas import DALLAS_COMPONENT_CLASS
-from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_RESOLUTION, \
-    CONF_UPDATE_INTERVAL
+from esphomeyaml.components.dallas import DallasComponent
+from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
+    CONF_RESOLUTION
 from esphomeyaml.helpers import HexIntLiteral, get_variable
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+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,
-    vol.Optional(CONF_DALLAS_ID): cv.variable_id,
-    vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=8, max=12)),
-}).extend(sensor.MQTT_SENSOR_ID_SCHEMA.schema)
+    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):
-    hub = get_variable(config.get(CONF_DALLAS_ID), DALLAS_COMPONENT_CLASS)
-    update_interval = config.get(CONF_UPDATE_INTERVAL)
-    if CONF_RESOLUTION in config and update_interval is None:
-        update_interval = 10000
-
+    for hub in get_variable(config[CONF_DALLAS_ID]):
+        yield
     if CONF_ADDRESS in config:
         address = HexIntLiteral(config[CONF_ADDRESS])
-        sensor_ = hub.Pget_sensor_by_address(address, update_interval,
-                                             config.get(CONF_RESOLUTION))
+        rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address, config.get(CONF_RESOLUTION))
     else:
-        sensor_ = hub.Pget_sensor_by_index(config[CONF_INDEX], update_interval,
-                                           config.get(CONF_RESOLUTION))
-    sensor.make_mqtt_sensor_for(sensor_, config)
+        rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
+                                       config.get(CONF_RESOLUTION))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/dht.py

@@ -1,31 +1,68 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
 from esphomeyaml.components import sensor
-from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
-from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
-    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, RawExpression, add, variable
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, CONF_ID
+from esphomeyaml.helpers import App, Application, add, gpio_output_pin_expression, variable, \
+    setup_component, PollingComponent, Pvariable
+from esphomeyaml.pins import gpio_output_pin_schema
 
-DHT_MODELS = ['AUTO_DETECT', 'DHT11', 'DHT22', 'AM2302', 'RHT03']
+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,
+}
+
+MakeDHTSensor = Application.struct('MakeDHTSensor')
+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('dht_sensor'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.input_output_pin,
-    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
-    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
-    vol.Optional(CONF_MODEL): vol.All(vol.Upper, vol.Any(*DHT_MODELS)),
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-})
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeDHTSensor),
+    cv.GenerateID(): cv.declare_variable_id(DHTComponent),
+    vol.Required(CONF_PIN): gpio_output_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): vol.All(vol.Upper, cv.one_of(*DHT_MODELS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
 
 
 def to_code(config):
-    rhs = App.make_dht_sensor(config[CONF_PIN], config[CONF_TEMPERATURE][CONF_NAME],
-                              config[CONF_HUMIDITY][CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
-    dht = variable('Application::MakeDHTComponent', config[CONF_ID], rhs)
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    dht = make.Pdht
+    Pvariable(config[CONF_ID], dht)
+
     if CONF_MODEL in config:
-        model = RawExpression('DHT::{}'.format(config[CONF_MODEL]))
-        add(dht.Pdht.set_dht_model(model))
-    sensor.setup_mqtt_sensor_component(dht.Pmqtt_temperature, config[CONF_TEMPERATURE])
-    sensor.setup_mqtt_sensor_component(dht.Pmqtt_humidity, config[CONF_HUMIDITY])
+        constant = DHT_MODELS[config[CONF_MODEL]]
+        add(dht.set_dht_model(constant))
+
+    sensor.setup_sensor(dht.Pget_temperature_sensor(),
+                        make.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(),
+                        make.Pmqtt_humidity, config[CONF_HUMIDITY])
+    setup_component(dht, config)
+
+
+BUILD_FLAGS = '-DUSE_DHT_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphomeyaml/components/sensor/dht12.py

@@ -0,0 +1,52 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor, i2c
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL, CONF_ID
+from esphomeyaml.helpers import App, Application, variable, setup_component, PollingComponent, \
+    Pvariable
+
+DEPENDENCIES = ['i2c']
+
+MakeDHT12Sensor = Application.struct('MakeDHT12Sensor')
+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(CONF_MAKE_ID): cv.declare_variable_id(MakeDHT12Sensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    dht = make.Pdht12
+    Pvariable(config[CONF_ID], dht)
+
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    setup_component(dht, config)
+
+
+BUILD_FLAGS = '-DUSE_DHT12_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphomeyaml/components/sensor/duty_cycle.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, gpio_input_pin_expression, variable, \
+    setup_component
+
+MakeDutyCycleSensor = Application.struct('MakeDutyCycleSensor')
+DutyCycleSensor = sensor.sensor_ns.class_('DutyCycleSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DutyCycleSensor),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeDutyCycleSensor),
+    vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema,
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    sensor.setup_sensor(make.Pduty, make.Pmqtt, config)
+    setup_component(make.Pduty, config)
+
+
+BUILD_FLAGS = '-DUSE_DUTY_CYCLE_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/esp32_hall.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, Application, variable, setup_component
+
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeESP32HallSensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    sensor.setup_sensor(make.Phall, make.Pmqtt, config)
+    setup_component(make.Phall, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_HALL_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/hdc1080.py

@@ -1,26 +1,53 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
-from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
-    CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, variable
+from esphomeyaml.components import sensor, i2c
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL, CONF_ID
+from esphomeyaml.helpers import App, Application, variable, setup_component, PollingComponent, \
+    Pvariable
 
 DEPENDENCIES = ['i2c']
 
+MakeHDC1080Sensor = Application.struct('MakeHDC1080Sensor')
+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('dht_sensor'): cv.register_variable_id,
-    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
-    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-})
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeHDC1080Sensor),
+    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 = variable('Application::MakeHDC1080Component', config[CONF_ID], rhs)
-    sensor.setup_mqtt_sensor_component(hdc1080.Pmqtt_temperature, config[CONF_TEMPERATURE])
-    sensor.setup_mqtt_sensor_component(hdc1080.Pmqtt_humidity, config[CONF_HUMIDITY])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    hdc1080 = make.Phdc1080
+    Pvariable(config[CONF_ID], hdc1080)
+
+    sensor.setup_sensor(hdc1080.Pget_temperature_sensor(),
+                        make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(hdc1080.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    setup_component(hdc1080, config)
+
+
+BUILD_FLAGS = '-DUSE_HDC1080_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphomeyaml/components/sensor/hlw8012.py

@@ -0,0 +1,75 @@
+import voluptuous as vol
+
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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 esphomeyaml.helpers import App, PollingComponent, Pvariable, add, gpio_output_pin_expression, \
+    setup_component
+
+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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_VOLTAGE, CONF_CURRENT, CONF_POWER):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/hmc5883l.py

@@ -0,0 +1,96 @@
+# coding=utf-8
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor, i2c
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, CONF_RANGE
+from esphomeyaml.helpers import App, Pvariable, add, setup_component, 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(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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z, CONF_HEADING):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/htu21d.py

@@ -1,26 +1,52 @@
 import voluptuous as vol
 
+from esphomeyaml.components import i2c, sensor
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
-from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
-    CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, variable
+from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL, CONF_ID
+from esphomeyaml.helpers import App, Application, PollingComponent, setup_component, variable, \
+    Pvariable
 
 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('htu21d'): cv.register_variable_id,
-    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
-    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-})
+    cv.GenerateID(): cv.declare_variable_id(HTU21DComponent),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeHTU21DSensor),
+    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 = variable('Application::MakeHTU21DComponent', config[CONF_ID], rhs)
-    sensor.setup_mqtt_sensor_component(htu21d.Pmqtt_temperature, config[CONF_TEMPERATURE])
-    sensor.setup_mqtt_sensor_component(htu21d.Pmqtt_humidity, config[CONF_HUMIDITY])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    htu21d = make.Phtu21d
+    Pvariable(config[CONF_ID], htu21d)
+
+    sensor.setup_sensor(htu21d.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(htu21d.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    setup_component(htu21d, config)
+
+
+BUILD_FLAGS = '-DUSE_HTU21D_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphomeyaml/components/sensor/hx711.py

@@ -0,0 +1,54 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_GAIN, CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL, CONF_CLK_PIN
+from esphomeyaml.helpers import App, Application, add, gpio_input_pin_expression, variable, \
+    setup_component
+
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeHX711Sensor),
+    vol.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema,
+    vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_GAIN): vol.All(cv.int_, cv.one_of(*GAINS)),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    hx711 = make.Phx711
+
+    if CONF_GAIN in config:
+        add(hx711.set_gain(GAINS[config[CONF_GAIN]]))
+
+    sensor.setup_sensor(hx711, make.Pmqtt, config)
+    setup_component(hx711, config)
+
+
+BUILD_FLAGS = '-DUSE_HX711'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/ina219.py

@@ -0,0 +1,74 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphomeyaml.components import i2c, sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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 esphomeyaml.helpers import App, PollingComponent, Pvariable, setup_component
+
+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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/ina3221.py

@@ -0,0 +1,89 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphomeyaml.components import i2c, sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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 esphomeyaml.helpers import App, PollingComponent, Pvariable, add, setup_component
+
+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(vol.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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for channel in (CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3):
+        if channel not in config:
+            continue
+        conf = config[channel]
+        for key in (CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER):
+            if key in conf:
+                ret.append(sensor.core_to_hass_config(data, conf[key]))
+    return ret

esphomeyaml/components/sensor/max6675.py

@@ -0,0 +1,42 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor, spi
+from esphomeyaml.components.spi import SPIComponent
+from esphomeyaml.const import CONF_CS_PIN, CONF_MAKE_ID, CONF_NAME, CONF_SPI_ID, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, get_variable, gpio_output_pin_expression, \
+    variable, setup_component
+
+MakeMAX6675Sensor = Application.struct('MakeMAX6675Sensor')
+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_MAKE_ID): cv.declare_variable_id(MakeMAX6675Sensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    max6675 = make.Pmax6675
+    sensor.setup_sensor(max6675, make.Pmqtt, config)
+    setup_component(max6675, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX6675_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/mhz19.py

@@ -0,0 +1,58 @@
+import voluptuous as vol
+
+from esphomeyaml.components import sensor, uart
+from esphomeyaml.components.uart import UARTComponent
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_CO2, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL, CONF_ID
+from esphomeyaml.helpers import App, Application, PollingComponent, get_variable, setup_component, \
+    variable, Pvariable
+
+DEPENDENCIES = ['uart']
+
+MakeMHZ19Sensor = Application.struct('MakeMHZ19Sensor')
+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_MAKE_ID): cv.declare_variable_id(MakeMHZ19Sensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    mhz19 = make.Pmhz19
+    Pvariable(config[CONF_ID], mhz19)
+    sensor.setup_sensor(mhz19.Pget_co2_sensor(), make.Pmqtt, 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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_CO2, CONF_TEMPERATURE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/mpu6050.py

@@ -0,0 +1,99 @@
+import voluptuous as vol
+
+from esphomeyaml.components import i2c, sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, PollingComponent, Pvariable, setup_component
+
+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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z, CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z,
+                CONF_TEMPERATURE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/mqtt_subscribe.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+from esphomeyaml.components import sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphomeyaml.helpers import App, Application, add, variable, setup_component, Component
+
+DEPENDENCIES = ['mqtt']
+
+MakeMQTTSubscribeSensor = Application.struct('MakeMQTTSubscribeSensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMQTTSubscribeSensor),
+    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])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    subs = make.Psensor
+
+    if CONF_QOS in config:
+        add(subs.set_qos(config[CONF_QOS]))
+
+    sensor.setup_sensor(subs, make.Pmqtt, config)
+    setup_component(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/ms5611.py

@@ -0,0 +1,57 @@
+import voluptuous as vol
+
+from esphomeyaml.components import i2c, sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_MAKE_ID, CONF_NAME, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, PollingComponent, Pvariable, add, \
+    setup_component, \
+    variable
+
+DEPENDENCIES = ['i2c']
+
+MakeMS5611Sensor = Application.struct('MakeMS5611Sensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMS5611Sensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    ms5611 = make.Pms5611
+    Pvariable(config[CONF_ID], ms5611)
+
+    if CONF_ADDRESS in config:
+        add(ms5611.set_address(config[CONF_ADDRESS]))
+
+    sensor.setup_sensor(ms5611.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(ms5611.Pget_pressure_sensor(), make.Pmqtt_pressure,
+                        config[CONF_PRESSURE])
+    setup_component(ms5611, config)
+
+
+BUILD_FLAGS = '-DUSE_MS5611'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]

esphomeyaml/components/sensor/pmsx003.py

@@ -0,0 +1,105 @@
+import voluptuous as vol
+
+from esphomeyaml.components import sensor, uart
+from esphomeyaml.components.uart import UARTComponent
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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 esphomeyaml.helpers import App, Pvariable, get_variable, setup_component, 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.iteritems():
+        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): vol.All(vol.Upper, cv.one_of(*PMSX003_TYPES)),
+
+    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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_PM_1_0, CONF_PM_2_5, CONF_PM_10_0, CONF_TEMPERATURE, CONF_HUMIDITY,
+                CONF_FORMALDEHYDE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/pulse_counter.py

@@ -1,58 +1,80 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
+from esphomeyaml import core, pins
 from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
-    CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
+from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_INTERNAL_FILTER, \
+    CONF_MAKE_ID, CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
     ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, RawExpression, add, variable
-
-ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
-
-GPIO_PULL_MODES = {
-    'PULLUP': 'GPIO_PULLUP_ONLY',
-    'PULLDOWN': 'GPIO_PULLDOWN_ONLY',
-    'PULLUP_PULLDOWN': 'GPIO_PULLUP_PULLDOWN',
-    'FLOATING': 'GPIO_FLOATING',
-}
-
-GPIO_PULL_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(GPIO_PULL_MODES.keys())))
+from esphomeyaml.helpers import App, Application, add, variable, gpio_input_pin_expression, \
+    setup_component
 
+PulseCounterCountMode = sensor.sensor_ns.enum('PulseCounterCountMode')
 COUNT_MODES = {
-    'DISABLE': 'PCNT_COUNT_DIS',
-    'INCREMENT': 'PCNT_COUNT_INC',
-    'DECREMENT': 'PCNT_COUNT_DEC',
+    'DISABLE': PulseCounterCountMode.PULSE_COUNTER_DISABLE,
+    'INCREMENT': PulseCounterCountMode.PULSE_COUNTER_INCREMENT,
+    'DECREMENT': PulseCounterCountMode.PULSE_COUNTER_DECREMENT,
 }
 
-COUNT_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(COUNT_MODES.keys())))
+COUNT_MODE_SCHEMA = vol.All(vol.Upper, cv.one_of(*COUNT_MODES))
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('pulse_counter'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.input_pin,
-    vol.Optional(CONF_PULL_MODE): GPIO_PULL_MODE_SCHEMA,
+PulseCounterBase = sensor.sensor_ns.class_('PulseCounterBase')
+MakePulseCounterSensor = Application.struct('MakePulseCounterSensor')
+PulseCounterSensorComponent = sensor.sensor_ns.class_('PulseCounterSensorComponent',
+                                                      sensor.PollingSensorComponent,
+                                                      PulseCounterBase)
+
+
+def validate_internal_filter(value):
+    if core.ESP_PLATFORM == ESP_PLATFORM_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
+    else:
+        return cv.positive_time_period_microseconds(value)
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PulseCounterSensorComponent),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakePulseCounterSensor),
+    vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema,
     vol.Optional(CONF_COUNT_MODE): vol.Schema({
         vol.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
         vol.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
     }),
-    vol.Optional(CONF_INTERNAL_FILTER): vol.All(vol.Coerce(int), vol.Range(min=0, max=1023)),
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+    vol.Optional(CONF_INTERNAL_FILTER): validate_internal_filter,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+
+    vol.Optional(CONF_PULL_MODE): cv.invalid("The pull_mode option has been removed in 1.7.0, "
+                                             "please use the pin mode schema now.")
+}).extend(cv.COMPONENT_SCHEMA.schema))
 
 
 def to_code(config):
-    rhs = App.make_pulse_counter_sensor(config[CONF_PIN], config[CONF_NAME],
+    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))
-    make = variable('Application::MakePulseCounter', config[CONF_ID], rhs)
+    make = variable(config[CONF_MAKE_ID], rhs)
     pcnt = make.Ppcnt
-    if CONF_PULL_MODE in config:
-        pull_mode = GPIO_PULL_MODES[config[CONF_PULL_MODE]]
-        add(pcnt.set_pull_mode(RawExpression(pull_mode)))
+
     if CONF_COUNT_MODE in config:
-        count_mode = config[CONF_COUNT_MODE]
-        rising_edge = COUNT_MODES[count_mode[CONF_RISING_EDGE]]
-        falling_edge = COUNT_MODES[count_mode[CONF_FALLING_EDGE]]
-        add(pcnt.set_edge_mode(RawExpression(rising_edge), RawExpression(falling_edge)))
+        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(config[CONF_INTERNAL_FILTER]))
-    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)
+        add(pcnt.set_filter_us(config[CONF_INTERNAL_FILTER]))
+
+    sensor.setup_sensor(pcnt, make.Pmqtt, config)
+    setup_component(pcnt, config)
+
+
+BUILD_FLAGS = '-DUSE_PULSE_COUNTER_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/rotary_encoder.py

@@ -0,0 +1,60 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_RESOLUTION
+from esphomeyaml.helpers import App, Application, add, gpio_input_pin_expression, variable, \
+    setup_component, 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'
+
+MakeRotaryEncoderSensor = Application.struct('MakeRotaryEncoderSensor')
+RotaryEncoderSensor = sensor.sensor_ns.class_('RotaryEncoderSensor', sensor.Sensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RotaryEncoderSensor),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeRotaryEncoderSensor),
+    vol.Required(CONF_PIN_A): pins.internal_gpio_input_pin_schema,
+    vol.Required(CONF_PIN_B): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_PIN_RESET): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_RESOLUTION): vol.All(cv.string, cv.one_of(*RESOLUTIONS)),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+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)
+    make = variable(config[CONF_MAKE_ID], rhs)
+    encoder = make.Protary_encoder
+
+    if CONF_PIN_RESET in config:
+        pin_i = None
+        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))
+
+    sensor.setup_sensor(encoder, make.Pmqtt, config)
+    setup_component(encoder, config)
+
+
+BUILD_FLAGS = '-DUSE_ROTARY_ENCODER_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/sht3xd.py

@@ -0,0 +1,54 @@
+import voluptuous as vol
+
+from esphomeyaml.components import i2c, sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, CONF_ID
+from esphomeyaml.helpers import App, Application, PollingComponent, setup_component, variable, \
+    Pvariable
+
+DEPENDENCIES = ['i2c']
+
+MakeSHT3XDSensor = Application.struct('MakeSHT3XDSensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeSHT3XDSensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    sht3xd = make.Psht3xd
+    Pvariable(config[CONF_ID], sht3xd)
+
+    sensor.setup_sensor(sht3xd.Pget_temperature_sensor(), make.Pmqtt_temperature,
+                        config[CONF_TEMPERATURE])
+    sensor.setup_sensor(sht3xd.Pget_humidity_sensor(), make.Pmqtt_humidity,
+                        config[CONF_HUMIDITY])
+    setup_component(sht3xd, config)
+
+
+BUILD_FLAGS = '-DUSE_SHT3XD'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphomeyaml/components/sensor/tcs34725.py

@@ -0,0 +1,111 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphomeyaml.components import i2c, sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_COLOR_TEMPERATURE, CONF_GAIN, CONF_ID, \
+    CONF_ILLUMINANCE, CONF_INTEGRATION_TIME, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, PollingComponent, Pvariable, add, setup_component
+
+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),
+    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS)),
+    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'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_RED_CHANNEL, CONF_GREEN_CHANNEL, CONF_BLUE_CHANNEL, CONF_CLEAR_CHANNEL,
+                CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/template.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, process_lambda, variable, Application, float_, optional, add, \
+    setup_component
+
+MakeTemplateSensor = Application.struct('MakeTemplateSensor')
+TemplateSensor = sensor.sensor_ns.class_('TemplateSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSensor),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateSensor),
+    vol.Required(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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    template = make.Ptemplate_
+
+    sensor.setup_sensor(template, make.Pmqtt, config)
+    setup_component(template, 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'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/total_daily_energy.py

@@ -0,0 +1,39 @@
+import voluptuous as vol
+
+from esphomeyaml.components import sensor, time
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_TIME_ID
+from esphomeyaml.helpers import App, Application, Component, get_variable, setup_component, variable
+
+DEPENDENCIES = ['time']
+
+CONF_POWER_ID = 'power_id'
+MakeTotalDailyEnergySensor = Application.struct('MakeTotalDailyEnergySensor')
+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_MAKE_ID): cv.declare_variable_id(MakeTotalDailyEnergySensor),
+    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)
+    make = variable(config[CONF_MAKE_ID], rhs)
+    total_energy = make.Ptotal_energy
+
+    sensor.setup_sensor(total_energy, make.Pmqtt, config)
+    setup_component(total_energy, config)
+
+
+BUILD_FLAGS = '-DUSE_TOTAL_DAILY_ENERGY_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/tsl2561.py

@@ -0,0 +1,70 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor, i2c
+from esphomeyaml.const import CONF_ADDRESS, CONF_GAIN, CONF_INTEGRATION_TIME, CONF_MAKE_ID, \
+    CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable, setup_component
+
+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
+
+
+MakeTSL2561Sensor = Application.struct('MakeTSL2561Sensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTSL2561Sensor),
+    vol.Optional(CONF_ADDRESS, default=0x39): cv.i2c_address,
+    vol.Optional(CONF_INTEGRATION_TIME): validate_integration_time,
+    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*GAINS)),
+    vol.Optional(CONF_IS_CS_PACKAGE): cv.boolean,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.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))
+    make_tsl = variable(config[CONF_MAKE_ID], rhs)
+    tsl2561 = make_tsl.Ptsl2561
+
+    if CONF_INTEGRATION_TIME in config:
+        add(tsl2561.set_integration_time(INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
+    if CONF_GAIN in config:
+        add(tsl2561.set_gain(GAINS[config[CONF_GAIN]]))
+    if CONF_IS_CS_PACKAGE in config:
+        add(tsl2561.set_is_cs_package(config[CONF_IS_CS_PACKAGE]))
+
+    sensor.setup_sensor(tsl2561, make_tsl.Pmqtt, config)
+    setup_component(tsl2561, config)
+
+
+BUILD_FLAGS = '-DUSE_TSL2561'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/ultrasonic.py

@@ -3,30 +3,47 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ECHO_PIN, CONF_ID, CONF_NAME, \
-    CONF_TIMEOUT_METER, CONF_TIMEOUT_TIME, CONF_TRIGGER_PIN, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, add, exp_gpio_input_pin, exp_gpio_output_pin, \
-    variable
+from esphomeyaml.const import CONF_ECHO_PIN, CONF_MAKE_ID, CONF_NAME, CONF_TIMEOUT_METER, \
+    CONF_TIMEOUT_TIME, CONF_TRIGGER_PIN, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, gpio_input_pin_expression, \
+    gpio_output_pin_expression, variable, setup_component
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('ultrasonic'): cv.register_variable_id,
-    vol.Required(CONF_TRIGGER_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Required(CONF_ECHO_PIN): pins.GPIO_INPUT_PIN_SCHEMA,
+MakeUltrasonicSensor = Application.struct('MakeUltrasonicSensor')
+UltrasonicSensorComponent = sensor.sensor_ns.class_('UltrasonicSensorComponent',
+                                                    sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UltrasonicSensorComponent),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeUltrasonicSensor),
+    vol.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema,
     vol.Exclusive(CONF_TIMEOUT_METER, 'timeout'): cv.positive_float,
-    vol.Exclusive(CONF_TIMEOUT_TIME, 'timeout'): cv.positive_int,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
-}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+    vol.Exclusive(CONF_TIMEOUT_TIME, 'timeout'): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}))
 
 
 def to_code(config):
-    trigger = exp_gpio_output_pin(config[CONF_TRIGGER_PIN])
-    echo = exp_gpio_input_pin(config[CONF_ECHO_PIN])
-    rhs = App.make_ultrasonic_sensor(trigger, echo, config[CONF_NAME],
+    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))
-    make = variable('Application::MakeUltrasonicSensor', config[CONF_ID], rhs)
+    make = variable(config[CONF_MAKE_ID], rhs)
     ultrasonic = make.Pultrasonic
+
     if CONF_TIMEOUT_TIME in config:
         add(ultrasonic.set_timeout_us(config[CONF_TIMEOUT_TIME]))
     elif CONF_TIMEOUT_METER in config:
         add(ultrasonic.set_timeout_m(config[CONF_TIMEOUT_METER]))
-    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)
+
+    sensor.setup_sensor(ultrasonic, make.Pmqtt, config)
+    setup_component(ultrasonic, config)
+
+
+BUILD_FLAGS = '-DUSE_ULTRASONIC_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/uptime.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, variable, setup_component
+
+MakeUptimeSensor = Application.struct('MakeUptimeSensor')
+UptimeSensor = sensor.sensor_ns.class_('UptimeSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UptimeSensor),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeUptimeSensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    uptime = make.Puptime
+
+    sensor.setup_sensor(uptime, make.Pmqtt, config)
+    setup_component(uptime, config)
+
+
+BUILD_FLAGS = '-DUSE_UPTIME_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/wifi_signal.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, variable, setup_component
+
+MakeWiFiSignalSensor = Application.struct('MakeWiFiSignalSensor')
+WiFiSignalSensor = sensor.sensor_ns.class_('WiFiSignalSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(WiFiSignalSensor),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeWiFiSignalSensor),
+    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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    wifi = make.Pwifi
+
+    sensor.setup_sensor(wifi, make.Pmqtt, config)
+    setup_component(wifi, config)
+
+
+BUILD_FLAGS = '-DUSE_WIFI_SIGNAL_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)

esphomeyaml/components/sensor/xiaomi_miflora.py

@@ -0,0 +1,53 @@
+import voluptuous as vol
+
+from esphomeyaml.components import esp32_ble_tracker, sensor
+from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_BATTERY_LEVEL, CONF_CONDUCTIVITY, CONF_ID, CONF_ILLUMINANCE, \
+    CONF_MAC_ADDRESS, CONF_MOISTURE, CONF_NAME, CONF_TEMPERATURE
+from esphomeyaml.helpers 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)
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_TEMPERATURE, CONF_MOISTURE, CONF_ILLUMINANCE, CONF_CONDUCTIVITY,
+                CONF_BATTERY_LEVEL):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/sensor/xiaomi_mijia.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+from esphomeyaml.components import esp32_ble_tracker, sensor
+from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_MAKE_ID, \
+    CONF_NAME, CONF_TEMPERATURE
+from esphomeyaml.helpers 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)
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_TEMPERATURE, CONF_HUMIDITY, CONF_BATTERY_LEVEL):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret

esphomeyaml/components/spi.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_CLK_PIN, CONF_ID, CONF_MISO_PIN, CONF_MOSI_PIN
+from esphomeyaml.helpers import App, Pvariable, esphomelib_ns, gpio_input_pin_expression, \
+    gpio_output_pin_expression, add, setup_component, Component
+
+SPIComponent = esphomelib_ns.class_('SPIComponent', Component)
+SPIDevice = esphomelib_ns.class_('SPIDevice')
+
+SPI_SCHEMA = vol.All(vol.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))
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [SPI_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        for clk in gpio_output_pin_expression(conf[CONF_CLK_PIN]):
+            yield
+        rhs = App.init_spi(clk)
+        spi = Pvariable(conf[CONF_ID], rhs)
+        if CONF_MISO_PIN in conf:
+            for miso in gpio_input_pin_expression(conf[CONF_MISO_PIN]):
+                yield
+            add(spi.set_miso(miso))
+        if CONF_MOSI_PIN in conf:
+            for mosi in gpio_input_pin_expression(conf[CONF_MOSI_PIN]):
+                yield
+            add(spi.set_mosi(mosi))
+
+        setup_component(spi, conf)
+
+
+BUILD_FLAGS = '-DUSE_SPI'

esphomeyaml/components/status_led.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv, pins
+from esphomeyaml.const import CONF_ID, CONF_PIN
+from esphomeyaml.helpers import App, Pvariable, esphomelib_ns, gpio_output_pin_expression, \
+    setup_component, Component
+
+StatusLEDComponent = esphomelib_ns.class_('StatusLEDComponent', Component)
+
+CONFIG_SCHEMA = vol.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'

esphomeyaml/components/stepper/__init__.py

@@ -0,0 +1,125 @@
+import voluptuous as vol
+
+from esphomeyaml.automation import ACTION_REGISTRY
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ACCELERATION, CONF_DECELERATION, CONF_ID, CONF_MAX_SPEED, \
+    CONF_POSITION, CONF_TARGET
+from esphomeyaml.helpers import Pvariable, TemplateArguments, add, add_job, esphomelib_ns, \
+    get_variable, int32, templatable, Action
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+# pylint: disable=invalid-name
+stepper_ns = esphomelib_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 = vol.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):
+    add_job(setup_stepper_core_, stepper_var, config)
+
+
+BUILD_FLAGS = '-DUSE_STEPPER'
+
+CONF_STEPPER_SET_TARGET = 'stepper.set_target'
+STEPPER_SET_TARGET_ACTION_SCHEMA = vol.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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_set_target_action(template_arg)
+    type = SetTargetAction.template(arg_type)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_TARGET], arg_type, int32):
+        yield None
+    add(action.set_target(template_))
+    yield action
+
+
+CONF_STEPPER_REPORT_POSITION = 'stepper.report_position'
+STEPPER_REPORT_POSITION_ACTION_SCHEMA = vol.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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_report_position_action(template_arg)
+    type = ReportPositionAction.template(arg_type)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_POSITION], arg_type, int32):
+        yield None
+    add(action.set_target(template_))
+    yield action

esphomeyaml/components/stepper/a4988.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+from esphomeyaml import pins
+from esphomeyaml.components import stepper
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_DIR_PIN, CONF_ID, CONF_SLEEP_PIN, CONF_STEP_PIN
+from esphomeyaml.helpers import App, Pvariable, add, gpio_output_pin_expression, setup_component, \
+    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'

esphomeyaml/components/switch/__init__.py

@@ -1,25 +1,115 @@
 import voluptuous as vol
 
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
+from esphomeyaml.components import mqtt
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ICON, CONF_ID, CONF_NAME
-from esphomeyaml.helpers import App, Pvariable, add, setup_mqtt_component
+from esphomeyaml.const import CONF_ICON, CONF_ID, CONF_INVERTED, CONF_MQTT_ID, CONF_INTERNAL, \
+    CONF_OPTIMISTIC
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, setup_mqtt_component, \
+    TemplateArguments, get_variable, Nameable, Action
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-MQTT_SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+switch_ns = esphomelib_ns.namespace('switch_')
+Switch = switch_ns.class_('Switch', Nameable)
+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)
+
+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,
+})
+
+SWITCH_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SWITCH_SCHEMA.schema)
+
+
+def setup_switch_core_(switch_var, mqtt_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]))
+
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_switch(switch_obj, mqtt_obj, config):
+    switch_var = Pvariable(config[CONF_ID], switch_obj, has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    setup_switch_core_(switch_var, mqtt_var, config)
+
+
+def register_switch(var, config):
+    switch_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    rhs = App.register_switch(switch_var)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], rhs, has_side_effects=True)
+    setup_switch_core_(switch_var, mqtt_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),
 })
 
 
-def setup_mqtt_switch(obj, config):
+@ACTION_REGISTRY.register(CONF_SWITCH_TOGGLE, SWITCH_TOGGLE_ACTION_SCHEMA)
+def switch_toggle_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_toggle_action(template_arg)
+    type = ToggleAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(arg_type)
+    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, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(arg_type)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'switch', config, include_state=True, include_command=True)
+    if ret is None:
+        return None
     if CONF_ICON in config:
-        add(obj.set_icon(config[CONF_ICON]))
-    setup_mqtt_component(obj, config)
-
-
-def make_mqtt_switch_for(exp, config):
-    rhs = App.make_mqtt_switch_for(exp, config[CONF_NAME])
-    mqtt_switch = Pvariable('switch_::MQTTSwitchComponent', config[CONF_ID], rhs)
-    setup_mqtt_switch(mqtt_switch, config)
+        ret['icon'] = config[CONF_ICON]
+    if CONF_OPTIMISTIC in config:
+        ret['optimistic'] = config[CONF_OPTIMISTIC]
+    return ret

esphomeyaml/components/switch/gpio.py

@@ -1,18 +1,35 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import switch
-from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_PIN
-from esphomeyaml.helpers import App, exp_gpio_output_pin, variable
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, Application, gpio_output_pin_expression, variable, \
+    setup_component, Component
 
-PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('gpio_switch'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+MakeGPIOSwitch = Application.struct('MakeGPIOSwitch')
+GPIOSwitch = switch.switch_ns.class_('GPIOSwitch', switch.Switch, Component)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(GPIOSwitch),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeGPIOSwitch),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+}).extend(cv.COMPONENT_SCHEMA.schema))
 
 
 def to_code(config):
-    rhs = App.make_gpio_switch(exp_gpio_output_pin(config[CONF_PIN]), config[CONF_NAME])
-    gpio = variable('Application::GPIOSwitchStruct', config[CONF_ID], rhs)
-    switch.setup_mqtt_switch(gpio.Pmqtt, config)
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_gpio_switch(config[CONF_NAME], pin)
+    make = variable(config[CONF_MAKE_ID], rhs)
+    gpio = make.Pswitch_
+
+    switch.setup_switch(gpio, make.Pmqtt, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_SWITCH'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/switch/ir_transmitter.py

@@ -1,87 +0,0 @@
-import voluptuous as vol
-
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import switch
-from esphomeyaml.components.ir_transmitter import IR_TRANSMITTER_COMPONENT_CLASS
-from esphomeyaml.const import CONF_ADDRESS, CONF_COMMAND, CONF_DATA, CONF_IR_TRANSMITTER_ID, \
-    CONF_LG, CONF_NBITS, CONF_NEC, CONF_PANASONIC, CONF_REPEAT, CONF_SONY, CONF_TIMES, \
-    CONF_WAIT_TIME_US, CONF_RAW, CONF_CARRIER_FREQUENCY
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import HexIntLiteral, MockObj, get_variable, ArrayInitializer
-
-PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('ir_transmitter'): cv.register_variable_id,
-    vol.Exclusive(CONF_NEC, 'code'): vol.Schema({
-        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
-        vol.Required(CONF_COMMAND): cv.hex_uint16_t,
-    }),
-    vol.Exclusive(CONF_LG, 'code'): vol.Schema({
-        vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), vol.Range(min=0, max=32)),
-    }),
-    vol.Exclusive(CONF_SONY, 'code'): vol.Schema({
-        vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), vol.Range(min=0, max=32)),
-    }),
-    vol.Exclusive(CONF_PANASONIC, 'code'): vol.Schema({
-        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
-        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
-    }),
-    vol.Exclusive(CONF_RAW, 'code'): vol.Schema({
-        vol.Required(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
-        vol.Required(CONF_DATA): [vol.Coerce(int)],
-    }),
-    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, vol.Schema({
-        vol.Required(CONF_TIMES): cv.positive_not_null_int,
-        vol.Required(CONF_WAIT_TIME_US): cv.uint32_t,
-    })),
-    vol.Optional(CONF_IR_TRANSMITTER_ID): cv.variable_id,
-}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
-
-SendData = MockObj('switch_::ir::SendData', '::')
-
-
-def safe_hex(value):
-    if value is None:
-        return None
-    return HexIntLiteral(value)
-
-
-def exp_send_data(config):
-    if CONF_NEC in config:
-        conf = config[CONF_NEC]
-        base = SendData.from_nec(safe_hex(conf[CONF_ADDRESS]),
-                                 safe_hex(conf[CONF_COMMAND]))
-    elif CONF_LG in config:
-        conf = config[CONF_LG]
-        base = SendData.from_lg(safe_hex(conf[CONF_DATA]), conf.get(CONF_NBITS))
-    elif CONF_SONY in config:
-        conf = config[CONF_SONY]
-        base = SendData.from_sony(safe_hex(conf[CONF_DATA]), conf.get(CONF_NBITS))
-    elif CONF_PANASONIC in config:
-        conf = config[CONF_PANASONIC]
-        base = SendData.from_panasonic(safe_hex(conf[CONF_ADDRESS]),
-                                       safe_hex(conf[CONF_COMMAND]))
-    elif CONF_RAW in config:
-        conf = config[CONF_RAW]
-        data = ArrayInitializer(*conf[CONF_DATA])
-        base = SendData.from_raw(data, conf[CONF_CARRIER_FREQUENCY])
-    else:
-        raise ESPHomeYAMLError(u"Unsupported IR mode {}".format(config))
-
-    if CONF_REPEAT in config:
-        if isinstance(config[CONF_REPEAT], int):
-            times = config[CONF_REPEAT]
-            wait_us = None
-        else:
-            times = config[CONF_REPEAT][CONF_TIMES]
-            wait_us = config[CONF_REPEAT][CONF_WAIT_TIME_US]
-        base = MockObj(unicode(base), u'.')
-        base = base.repeat(times, wait_us)
-    return base
-
-
-def to_code(config):
-    ir = get_variable(config.get(CONF_IR_TRANSMITTER_ID), IR_TRANSMITTER_COMPONENT_CLASS)
-    send_data = exp_send_data(config)
-    switch.make_mqtt_switch_for(ir.create_transmitter(send_data), config)

esphomeyaml/components/switch/output.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphomeyaml.components import output, switch
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphomeyaml.helpers import App, Application, Component, get_variable, setup_component, variable
+
+MakeOutputSwitch = Application.struct('MakeOutputSwitch')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeOutputSwitch),
+    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_)
+    make = variable(config[CONF_MAKE_ID], rhs)
+    switch_ = make.Pswitch_
+
+    switch.setup_switch(switch_, make.Pmqtt, config)
+    setup_component(switch, config)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT_SWITCH'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/switch/remote_transmitter.py

@@ -0,0 +1,152 @@
+import voluptuous as vol
+
+from esphomeyaml.components import switch
+from esphomeyaml.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 esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ADDRESS, CONF_CARRIER_FREQUENCY, CONF_CHANNEL, CONF_CODE, \
+    CONF_COMMAND, CONF_DATA, CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_INVERTED, 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
+from esphomeyaml.helpers import ArrayInitializer, Pvariable, add, get_variable
+
+DEPENDENCIES = ['remote_transmitter']
+
+REMOTE_KEYS = [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_REMOTE_TRANSMITTER_ID = 'remote_transmitter_id'
+CONF_TRANSMITTER_ID = 'transmitter_id'
+
+RemoteTransmitter = remote_ns.class_('RemoteTransmitter', switch.Switch)
+LGTransmitter = remote_ns.class_('LGTransmitter', RemoteTransmitter)
+NECTransmitter = remote_ns.class_('NECTransmitter', RemoteTransmitter)
+PanasonicTransmitter = remote_ns.class_('PanasonicTransmitter', RemoteTransmitter)
+RawTransmitter = remote_ns.class_('RawTransmitter', 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)
+
+validate_raw_data = [vol.Any(vol.Coerce(int), cv.time_period_microseconds)]
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RemoteTransmitter),
+    vol.Optional(CONF_LG): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), cv.one_of(28, 32)),
+    }),
+    vol.Optional(CONF_NEC): vol.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint16_t,
+    }),
+    vol.Optional(CONF_SAMSUNG): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_SONY): vol.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), cv.one_of(12, 15, 20)),
+    }),
+    vol.Optional(CONF_PANASONIC): vol.Schema({
+        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
+        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
+    }),
+    vol.Optional(CONF_RAW): vol.Any(validate_raw_data, vol.Schema({
+        vol.Required(CONF_DATA): validate_raw_data,
+        vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
+    })),
+    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, vol.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_LG:
+        return LGTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
+    elif key == CONF_NEC:
+        return NECTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    elif key == CONF_PANASONIC:
+        return PanasonicTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    elif key == CONF_SAMSUNG:
+        return SamsungTransmitter.new(name, config[CONF_DATA])
+    elif key == CONF_SONY:
+        return SonyTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
+    elif key == CONF_RAW:
+        if isinstance(config, dict):
+            data = config[CONF_DATA]
+            carrier_frequency = config.get(CONF_CARRIER_FREQUENCY)
+        else:
+            data = config
+            carrier_frequency = None
+        return RawTransmitter.new(name, ArrayInitializer(*data, multiline=False),
+                                  carrier_frequency)
+    elif 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]))
+    elif 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])
+    elif 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])
+    elif 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])
+    elif 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])
+    else:
+        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'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/switch/restart.py

@@ -1,14 +1,28 @@
+import voluptuous as vol
+
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import switch
-from esphomeyaml.const import CONF_ID, CONF_NAME
-from esphomeyaml.helpers import App, Pvariable
+from esphomeyaml.const import CONF_INVERTED, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable
 
-PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('restart_switch'): cv.register_variable_id,
-}).extend(switch.MQTT_SWITCH_SCHEMA.schema)
+MakeRestartSwitch = Application.struct('MakeRestartSwitch')
+RestartSwitch = switch.switch_ns.class_('RestartSwitch', switch.Switch)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RestartSwitch),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeRestartSwitch),
+    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])
-    mqtt = Pvariable('switch_::MQTTSwitchComponent', config[CONF_ID], rhs)
-    switch.setup_mqtt_switch(mqtt, config)
+    restart = variable(config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(restart.Prestart, restart.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_RESTART_SWITCH'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/switch/shutdown.py

@@ -0,0 +1,28 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_INVERTED, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable
+
+MakeShutdownSwitch = Application.struct('MakeShutdownSwitch')
+ShutdownSwitch = switch.switch_ns.class_('ShutdownSwitch', switch.Switch)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ShutdownSwitch),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeShutdownSwitch),
+    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 = variable(config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(shutdown.Pshutdown, shutdown.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_SHUTDOWN_SWITCH'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/switch/template.py

@@ -0,0 +1,56 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import automation
+from esphomeyaml.components import switch
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_TURN_OFF_ACTION, \
+    CONF_TURN_ON_ACTION, CONF_OPTIMISTIC, CONF_RESTORE_STATE
+from esphomeyaml.helpers import App, Application, process_lambda, variable, NoArg, add, bool_, \
+    optional, setup_component, Component
+
+MakeTemplateSwitch = Application.struct('MakeTemplateSwitch')
+TemplateSwitch = switch.switch_ns.class_('TemplateSwitch', switch.Switch, Component)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSwitch),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateSwitch),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): 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), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
+
+
+def to_code(config):
+    rhs = App.make_template_switch(config[CONF_NAME])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    template = make.Ptemplate_
+
+    switch.setup_switch(template, make.Pmqtt, 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_automation(template.get_turn_off_trigger(), NoArg,
+                                    config[CONF_TURN_OFF_ACTION])
+    if CONF_TURN_ON_ACTION in config:
+        automation.build_automation(template.get_turn_on_trigger(), NoArg,
+                                    config[CONF_TURN_ON_ACTION])
+    if CONF_OPTIMISTIC in config:
+        add(template.set_optimistic(config[CONF_OPTIMISTIC]))
+
+    if CONF_RESTORE_STATE in config:
+        add(template.set_restore_state(config[CONF_RESTORE_STATE]))
+
+    setup_component(template, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SWITCH'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/switch/uart.py

@@ -0,0 +1,50 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import switch, uart
+from esphomeyaml.components.uart import UARTComponent
+from esphomeyaml.const import CONF_DATA, CONF_INVERTED, CONF_MAKE_ID, CONF_NAME, CONF_UART_ID
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, Application, ArrayInitializer, get_variable, variable
+
+DEPENDENCIES = ['uart']
+
+MakeUARTSwitch = Application.struct('MakeUARTSwitch')
+UARTSwitch = switch.switch_ns.class_('UARTSwitch', switch.Switch, uart.UARTDevice)
+
+
+def validate_data(value):
+    if isinstance(value, unicode):
+        return value.encode('utf-8')
+    elif isinstance(value, str):
+        return value
+    elif isinstance(value, list):
+        return vol.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_MAKE_ID): cv.declare_variable_id(MakeUARTSwitch),
+    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], ArrayInitializer(*data, multiline=False))
+    restart = variable(config[CONF_MAKE_ID], rhs)
+    switch.setup_switch(restart.Puart, restart.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_UART_SWITCH'
+
+
+def to_hass_config(data, config):
+    return switch.core_to_hass_config(data, config)

esphomeyaml/components/text_sensor/__init__.py

@@ -0,0 +1,70 @@
+import voluptuous as vol
+
+from esphomeyaml import automation
+from esphomeyaml.components import mqtt
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_ON_VALUE, \
+    CONF_TRIGGER_ID
+from esphomeyaml.helpers import App, Pvariable, add, add_job, esphomelib_ns, setup_mqtt_component, \
+    std_string, Nameable, Trigger
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+# pylint: disable=invalid-name
+text_sensor_ns = esphomelib_ns.namespace('text_sensor')
+TextSensor = text_sensor_ns.class_('TextSensor', Nameable)
+MQTTTextSensor = text_sensor_ns.class_('MQTTTextSensor', mqtt.MQTTComponent)
+
+TextSensorStateTrigger = text_sensor_ns.class_('TextSensorStateTrigger',
+                                               Trigger.template(std_string))
+
+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, mqtt_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_automation(trigger, std_string, conf)
+
+    setup_mqtt_component(mqtt_var, config)
+
+
+def setup_text_sensor(text_sensor_obj, mqtt_obj, config):
+    sensor_var = Pvariable(config[CONF_ID], text_sensor_obj, has_side_effects=False)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
+    add_job(setup_text_sensor_core_, sensor_var, mqtt_var, config)
+
+
+def register_text_sensor(var, config):
+    text_sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    rhs = App.register_text_sensor(text_sensor_var)
+    mqtt_var = Pvariable(config[CONF_MQTT_ID], rhs, has_side_effects=True)
+    add_job(setup_text_sensor_core_, text_sensor_var, mqtt_var, config)
+
+
+BUILD_FLAGS = '-DUSE_TEXT_SENSOR'
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'sensor', config, include_state=True, include_command=False)
+    if ret is None:
+        return None
+    if CONF_ICON in config:
+        ret['icon'] = config[CONF_ICON]
+    return ret

esphomeyaml/components/text_sensor/mqtt_subscribe.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphomeyaml.components import text_sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphomeyaml.helpers import App, Application, add, variable, setup_component, Component
+
+DEPENDENCIES = ['mqtt']
+
+MakeMQTTSubscribeTextSensor = Application.struct('MakeMQTTSubscribeTextSensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMQTTSubscribeTextSensor),
+    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])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    sensor_ = make.Psensor
+
+    if CONF_QOS in config:
+        add(sensor_.set_qos(config[CONF_QOS]))
+
+    text_sensor.setup_text_sensor(sensor_, make.Pmqtt, config)
+    setup_component(sensor_, config)
+
+
+BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_TEXT_SENSOR'
+
+
+def to_hass_config(data, config):
+    return text_sensor.core_to_hass_config(data, config)

esphomeyaml/components/text_sensor/template.py

@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphomeyaml.components import text_sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, optional, process_lambda, std_string, \
+    variable, setup_component, PollingComponent
+
+MakeTemplateTextSensor = Application.struct('MakeTemplateTextSensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateTextSensor),
+    vol.Required(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))
+    make = variable(config[CONF_MAKE_ID], rhs)
+    template = make.Ptemplate_
+    text_sensor.setup_text_sensor(template, make.Pmqtt, config)
+    setup_component(template, 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'
+
+
+def to_hass_config(data, config):
+    return text_sensor.core_to_hass_config(data, config)

esphomeyaml/components/text_sensor/version.py

@@ -0,0 +1,27 @@
+from esphomeyaml.components import text_sensor
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable, setup_component, Component
+
+MakeVersionTextSensor = Application.struct('MakeVersionTextSensor')
+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),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeVersionTextSensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_version_text_sensor(config[CONF_NAME])
+    make = variable(config[CONF_MAKE_ID], rhs)
+    text_sensor.setup_text_sensor(make.Psensor, make.Pmqtt, config)
+    setup_component(make.Psensor, config)
+
+
+BUILD_FLAGS = '-DUSE_VERSION_TEXT_SENSOR'
+
+
+def to_hass_config(data, config):
+    return text_sensor.core_to_hass_config(data, config)

esphomeyaml/components/time/__init__.py

@@ -0,0 +1,303 @@
+import datetime
+import logging
+import math
+
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import automation
+from esphomeyaml.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 esphomeyaml.helpers import App, NoArg, Pvariable, add, add_job, esphomelib_ns, \
+    ArrayInitializer, Component, Trigger
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+time_ns = esphomelib_ns.namespace('time')
+RealTimeClockComponent = time_ns.class_('RealTimeClockComponent', Component)
+CronTrigger = time_ns.class_('CronTrigger', Trigger.template(NoArg), Component)
+EsphomelibTime = time_ns.struct('EsphomelibTime')
+
+
+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'
+    elif offset_minute == 0 and offset_second == 0:
+        return '{}'.format(offset_hour)
+    elif 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 (pip2 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, (str, unicode)) 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 == '*' or part == '?':
+        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(ArrayInitializer(*seconds, multiline=False)))
+
+        minutes = conf.get(CONF_MINUTES, [x for x in range(0, 60)])
+        add(trigger.add_minutes(ArrayInitializer(*minutes, multiline=False)))
+
+        hours = conf.get(CONF_HOURS, [x for x in range(0, 24)])
+        add(trigger.add_hours(ArrayInitializer(*hours, multiline=False)))
+
+        days_of_month = conf.get(CONF_DAYS_OF_MONTH, [x for x in range(1, 32)])
+        add(trigger.add_days_of_month(ArrayInitializer(*days_of_month, multiline=False)))
+
+        months = conf.get(CONF_MONTHS, [x for x in range(1, 13)])
+        add(trigger.add_months(ArrayInitializer(*months, multiline=False)))
+
+        days_of_week = conf.get(CONF_DAYS_OF_WEEK, [x for x in range(1, 8)])
+        add(trigger.add_days_of_week(ArrayInitializer(*days_of_week, multiline=False)))
+
+        automation.build_automation(trigger, NoArg, conf)
+
+
+def setup_time(time_var, config):
+    add_job(setup_time_core_, time_var, config)
+
+
+BUILD_FLAGS = '-DUSE_TIME'

esphomeyaml/components/time/sntp.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import time as time_
+from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_SERVERS
+from esphomeyaml.helpers import App, Pvariable, add, setup_component
+
+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.string], vol.Length(min=1, max=3)),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+}).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'

esphomeyaml/components/uart.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.const import CONF_BAUD_RATE, CONF_ID, CONF_RX_PIN, CONF_TX_PIN
+from esphomeyaml.helpers import App, Pvariable, esphomelib_ns, setup_component, Component
+
+UARTComponent = esphomelib_ns.class_('UARTComponent', Component)
+UARTDevice = esphomelib_ns.class_('UARTDevice')
+
+UART_SCHEMA = vol.All(vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(UARTComponent),
+    vol.Optional(CONF_TX_PIN): pins.output_pin,
+    vol.Optional(CONF_RX_PIN): pins.input_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))
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [UART_SCHEMA])
+
+
+def to_code(config):
+    for conf in config:
+        tx = conf.get(CONF_TX_PIN, -1)
+        rx = conf.get(CONF_RX_PIN, -1)
+        rhs = App.init_uart(tx, rx, conf[CONF_BAUD_RATE])
+        var = Pvariable(conf[CONF_ID], rhs)
+
+        setup_component(var, conf)
+
+
+BUILD_FLAGS = '-DUSE_UART'

esphomeyaml/components/web_server.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphomeyaml import core
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_CSS_URL, CONF_ID, CONF_JS_URL, CONF_PORT, ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, Component, Pvariable, StoringController, add, esphomelib_ns, \
+    setup_component
+
+WebServer = esphomelib_ns.class_('WebServer', Component, StoringController)
+
+CONFIG_SCHEMA = vol.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)
+
+
+BUILD_FLAGS = '-DUSE_WEB_SERVER'
+
+
+def lib_deps(config):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return 'FS'
+    return ''

esphomeyaml/components/wifi.py

@@ -1,46 +1,145 @@
 import voluptuous as vol
 
+from esphomeyaml import core
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DNS1, CONF_DNS2, CONF_GATEWAY, CONF_HOSTNAME, CONF_ID, \
-    CONF_MANUAL_IP, CONF_PASSWORD, CONF_SSID, CONF_STATIC_IP, CONF_SUBNET, CONF_WIFI
-from esphomeyaml.helpers import App, MockObj, Pvariable, StructInitializer, add
+from esphomeyaml.const import CONF_AP, CONF_CHANNEL, CONF_DNS1, CONF_DNS2, CONF_DOMAIN, \
+    CONF_GATEWAY, CONF_HOSTNAME, CONF_ID, CONF_MANUAL_IP, CONF_PASSWORD, CONF_POWER_SAVE_MODE,\
+    CONF_REBOOT_TIMEOUT, CONF_SSID, CONF_STATIC_IP, CONF_SUBNET, ESP_PLATFORM_ESP8266
+from esphomeyaml.helpers import App, Pvariable, StructInitializer, add, esphomelib_ns, global_ns, \
+    Component
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
-    cv.GenerateID(CONF_WIFI): cv.register_variable_id,
-    vol.Required(CONF_SSID): cv.ssid,
-    vol.Optional(CONF_PASSWORD): cv.string,
-    vol.Optional(CONF_MANUAL_IP): vol.Schema({
-        vol.Required(CONF_STATIC_IP): cv.ipv4,
-        vol.Required(CONF_GATEWAY): cv.ipv4,
-        vol.Required(CONF_SUBNET): cv.ipv4,
-        vol.Inclusive(CONF_DNS1, 'dns'): cv.ipv4,
-        vol.Inclusive(CONF_DNS2, 'dns'): cv.ipv4,
-    }),
-    vol.Optional(CONF_HOSTNAME): cv.hostname,
+
+def validate_password(value):
+    value = cv.string(value)
+    if not value:
+        return value
+    if len(value) < 8:
+        raise vol.Invalid(u"WPA password must be at least 8 characters long")
+    if len(value) > 63:
+        raise vol.Invalid(u"WPA password must be at most 63 characters long")
+    return value
+
+
+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 = vol.Schema({
+    vol.Required(CONF_STATIC_IP): cv.ipv4,
+    vol.Required(CONF_GATEWAY): cv.ipv4,
+    vol.Required(CONF_SUBNET): cv.ipv4,
 })
 
-IPAddress = MockObj('IPAddress')
+STA_MANUAL_IP_SCHEMA = AP_MANUAL_IP_SCHEMA.extend({
+    vol.Inclusive(CONF_DNS1, 'dns'): cv.ipv4,
+    vol.Inclusive(CONF_DNS2, 'dns'): cv.ipv4,
+})
+
+WIFI_NETWORK_BASE = vol.Schema({
+    vol.Required(CONF_SSID): cv.ssid,
+    vol.Optional(CONF_PASSWORD): validate_password,
+    vol.Optional(CONF_CHANNEL): validate_channel,
+    vol.Optional(CONF_MANUAL_IP): AP_MANUAL_IP_SCHEMA,
+})
+
+WIFI_NETWORK_AP = WIFI_NETWORK_BASE.extend({
+    vol.Optional(CONF_MANUAL_IP): AP_MANUAL_IP_SCHEMA,
+})
+
+WIFI_NETWORK_STA = WIFI_NETWORK_BASE.extend({
+    vol.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
+})
+
+
+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 not in config and CONF_AP not in config:
+        raise vol.Invalid("Please specify at least an SSID or an Access Point "
+                          "to create.")
+    return config
+
+
+IPAddress = global_ns.class_('IPAddress')
+ManualIP = esphomelib_ns.struct('ManualIP')
+WiFiComponent = esphomelib_ns.class_('WiFiComponent', Component)
+WiFiAp = esphomelib_ns.struct('WiFiAp')
+
+WiFiPowerSaveMode = esphomelib_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,
+}
+
+CONFIG_SCHEMA = vol.All(vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(WiFiComponent),
+    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_HOSTNAME): cv.hostname,
+    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): vol.All(vol.Upper, cv.one_of(*WIFI_POWER_SAVE_MODES)),
+}), validate)
 
 
 def safe_ip(ip):
     if ip is None:
-        return 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):
+    return StructInitializer(
+        WiFiAp,
+        ('ssid', config.get(CONF_SSID, "")),
+        ('password', config.get(CONF_PASSWORD, "")),
+        ('channel', config.get(CONF_CHANNEL, -1)),
+        ('manual_ip', manual_ip(config.get(CONF_MANUAL_IP))),
+    )
+
+
 def to_code(config):
-    rhs = App.init_wifi(config[CONF_SSID], config.get(CONF_PASSWORD))
-    wifi = Pvariable('WiFiComponent', config[CONF_ID], rhs)
-    if CONF_MANUAL_IP in config:
-        manual_ip = config[CONF_MANUAL_IP]
-        exp = StructInitializer(
-            'ManualIP',
-            ('static_ip', safe_ip(manual_ip[CONF_STATIC_IP])),
-            ('gateway', safe_ip(manual_ip[CONF_GATEWAY])),
-            ('subnet', safe_ip(manual_ip[CONF_SUBNET])),
-            ('dns1', safe_ip(manual_ip.get(CONF_DNS1))),
-            ('dns2', safe_ip(manual_ip.get(CONF_DNS2))),
-        )
-        add(wifi.set_manual_ip(exp))
+    rhs = App.init_wifi()
+    wifi = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_SSID in config:
+        add(wifi.set_sta(wifi_network(config)))
+
+    if CONF_AP in config:
+        add(wifi.set_ap(wifi_network(config[CONF_AP])))
+
     if CONF_HOSTNAME in config:
         add(wifi.set_hostname(config[CONF_HOSTNAME]))
+
+    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]]))
+
+
+def lib_deps(config):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+        return 'ESP8266WiFi'
+    return None

esphomeyaml/config.json

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

esphomeyaml/config.py

@@ -7,40 +7,21 @@ from collections import OrderedDict
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import helpers, yaml_util
-from esphomeyaml.const import CONF_BOARD, CONF_ESPHOMEYAML, CONF_LIBRARY_URI, CONF_MQTT, \
-    CONF_NAME, \
-    CONF_PLATFORM, CONF_SIMPLIFY, CONF_WIFI, ESP_PLATFORMS, ESP_PLATFORM_ESP32, \
-    ESP_PLATFORM_ESP8266
+from esphomeyaml import core, yaml_util, core_config
+from esphomeyaml.const import CONF_ESPHOMEYAML, CONF_PLATFORM, CONF_WIFI, ESP_PLATFORMS
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, add, add_task, color
+from esphomeyaml.helpers import color, MockObjClass
+from esphomeyaml.util import safe_print
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_LIBRARY_URI = u'https://github.com/OttoWinter/esphomelib.git#v1.2.1'
-
-CORE_SCHEMA = vol.Schema({
-    vol.Required(CONF_NAME): cv.valid_name,
-    vol.Required(CONF_PLATFORM): vol.All(
-        vol.Upper, vol.Any(ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266)),
-    vol.Required(CONF_BOARD): cv.string,
-    vol.Optional(CONF_LIBRARY_URI, default=DEFAULT_LIBRARY_URI): cv.string,
-    vol.Optional(CONF_SIMPLIFY, default=True): cv.boolean,
-})
-
 REQUIRED_COMPONENTS = [
-    CONF_ESPHOMEYAML, CONF_WIFI, CONF_MQTT
+    CONF_ESPHOMEYAML, CONF_WIFI
 ]
-
 _COMPONENT_CACHE = {}
 _ALL_COMPONENTS = []
 
 
-def core_to_code(config):
-    add(App.set_name(config[CONF_NAME]))
-
-
 def get_component(domain):
     if domain in _COMPONENT_CACHE:
         return _COMPONENT_CACHE[domain]
@@ -48,9 +29,8 @@ def get_component(domain):
     path = 'esphomeyaml.components.{}'.format(domain)
     try:
         module = importlib.import_module(path)
-    except ImportError as err:
+    except (ImportError, ValueError) as err:
         _LOGGER.debug(err)
-        pass
     else:
         _COMPONENT_CACHE[domain] = module
         return module
@@ -67,8 +47,17 @@ def is_platform_component(component):
     return hasattr(component, 'PLATFORM_SCHEMA')
 
 
-def validate_schema(config, schema):
-    return schema(config)
+def iter_components(config):
+    for domain, conf in config.iteritems():
+        if domain == CONF_ESPHOMEYAML:
+            continue
+        component = get_component(domain)
+        yield domain, component, conf
+        if is_platform_component(component):
+            for p_config in conf:
+                p_name = u"{}.{}".format(domain, p_config[CONF_PLATFORM])
+                platform = get_component(p_name)
+                yield p_name, platform, p_config
 
 
 class Config(OrderedDict):
@@ -82,12 +71,74 @@ class Config(OrderedDict):
         self.errors.append((message, domain, config))
 
 
+def iter_ids(config, prefix=None, parent=None):
+    prefix = prefix or []
+    parent = parent or {}
+    if isinstance(config, core.ID):
+        yield config, prefix, parent
+    elif isinstance(config, core.Lambda):
+        for id in config.requires_ids:
+            yield id, prefix, parent
+    elif isinstance(config, list):
+        for i, item in enumerate(config):
+            for result in iter_ids(item, prefix + [str(i)], config):
+                yield result
+    elif isinstance(config, dict):
+        for key, value in config.iteritems():
+            for result in iter_ids(value, prefix + [str(key)], config):
+                yield result
+
+
+def do_id_pass(result):
+    declare_ids = []
+    searching_ids = []
+    for id, prefix, config 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("ID {} redefined!".format(id.id), '.'.join(prefix), config)
+                continue
+            declare_ids.append((id, prefix, config))
+        else:
+            searching_ids.append((id, prefix, config))
+    # 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, prefix, config 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), '.'.join(prefix), config)
+                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))
+
+        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),
+                                 '.'.join(prefix), config)
+
+
 def validate_config(config):
     global _ALL_COMPONENTS
 
     for req in REQUIRED_COMPONENTS:
         if req not in config:
-            raise ESPHomeYAMLError("Component %s is required for esphomeyaml.", req)
+            raise ESPHomeYAMLError("Component {} is required for esphomeyaml.".format(req))
 
     _ALL_COMPONENTS = list(config.keys())
 
@@ -96,31 +147,63 @@ def validate_config(config):
     def _comp_error(ex, domain, config):
         result.add_error(_format_config_error(ex, domain, config), domain, config)
 
-    try:
-        result[CONF_ESPHOMEYAML] = validate_schema(config[CONF_ESPHOMEYAML], CORE_SCHEMA)
-    except vol.Invalid as ex:
-        _comp_error(ex, CONF_ESPHOMEYAML, config)
-
+    # Step 1: Load everything
     for domain, conf in config.iteritems():
-        if domain == CONF_ESPHOMEYAML:
+        domain = str(domain)
+        if domain == CONF_ESPHOMEYAML or domain.startswith('.'):
             continue
         if conf is None:
             conf = {}
         component = get_component(domain)
         if component is None:
-            result.add_error(u"Component not found: {}".format(domain))
+            result.add_error(u"Component not found: {}".format(domain), domain, conf)
+            continue
+
+        if not hasattr(component, 'PLATFORM_SCHEMA'):
+            continue
+
+        for p_config in conf:
+            if not isinstance(p_config, dict):
+                result.add_error(u"Platform schemas must have 'platform:' key", )
+                continue
+            p_name = p_config.get(u'platform')
+            if p_name is None:
+                result.add_error(u"No platform specified for {}".format(domain))
+                continue
+            p_domain = u'{}.{}'.format(domain, p_name)
+            platform = get_platform(domain, p_name)
+            if platform is None:
+                result.add_error(u"Platform not found: '{}'".format(p_domain), p_domain, p_config)
+                continue
+
+    # Step 2: Validate configuration
+    try:
+        result[CONF_ESPHOMEYAML] = core_config.CONFIG_SCHEMA(config[CONF_ESPHOMEYAML])
+    except vol.Invalid as ex:
+        _comp_error(ex, CONF_ESPHOMEYAML, config[CONF_ESPHOMEYAML])
+
+    for domain, conf in config.iteritems():
+        if domain == CONF_ESPHOMEYAML or domain.startswith('.'):
+            continue
+        if conf is None:
+            conf = {}
+        domain = str(domain)
+        component = get_component(domain)
+        if component is None:
             continue
 
         esp_platforms = getattr(component, 'ESP_PLATFORMS', ESP_PLATFORMS)
-        if cv.ESP_PLATFORM not in esp_platforms:
-            result.add_error(u"Component {} doesn't support {}.".format(domain, cv.ESP_PLATFORM))
+        if core.ESP_PLATFORM not in esp_platforms:
+            result.add_error(u"Component {} doesn't support {}.".format(domain, core.ESP_PLATFORM),
+                             domain, conf)
             continue
 
         success = True
         dependencies = getattr(component, 'DEPENDENCIES', [])
         for dependency in dependencies:
             if dependency not in _ALL_COMPONENTS:
-                result.add_error(u"Component {} requires {}".format(domain, dependency))
+                result.add_error(u"Component {} requires component {}".format(domain, dependency),
+                                 domain, conf)
                 success = False
         if not success:
             continue
@@ -130,38 +213,56 @@ def validate_config(config):
                 validated = component.CONFIG_SCHEMA(conf)
                 result[domain] = validated
             except vol.Invalid as ex:
-                _comp_error(ex, domain, config)
+                _comp_error(ex, domain, conf)
                 continue
 
         if not hasattr(component, 'PLATFORM_SCHEMA'):
             continue
 
         platforms = []
-        for i, p_config in enumerate(conf):
+        for p_config in conf:
             if not isinstance(p_config, dict):
-                result.add_error(u"Platform schemas mus have 'platform:' key")
                 continue
             p_name = p_config.get(u'platform')
             if p_name is None:
-                result.add_error(u"No platform specified for {}".format(domain))
                 continue
+            p_domain = u'{}.{}'.format(domain, p_name)
             platform = get_platform(domain, p_name)
             if platform is None:
-                result.add_error(u"Platform not found: {}.{}")
+                continue
+
+            success = True
+            dependencies = getattr(platform, 'DEPENDENCIES', [])
+            for dependency in dependencies:
+                if dependency not in _ALL_COMPONENTS:
+                    result.add_error(
+                        u"Platform {} requires component {}".format(p_domain, dependency),
+                        p_domain, p_config)
+                    success = False
+            if not success:
+                continue
+
+            esp_platforms = getattr(platform, 'ESP_PLATFORMS', ESP_PLATFORMS)
+            if core.ESP_PLATFORM not in esp_platforms:
+                result.add_error(
+                    u"Platform {} doesn't support {}.".format(p_domain, core.ESP_PLATFORM),
+                    p_domain, p_config)
                 continue
 
             if hasattr(platform, u'PLATFORM_SCHEMA'):
                 try:
                     p_validated = platform.PLATFORM_SCHEMA(p_config)
                 except vol.Invalid as ex:
-                    _comp_error(ex, u'{}.{}'.format(domain, p_name), p_config)
+                    _comp_error(ex, p_domain, p_config)
                     continue
                 platforms.append(p_validated)
         result[domain] = platforms
+
+    do_id_pass(result)
     return result
 
 
-REQUIRED = ['esphomeyaml', 'wifi', 'mqtt']
+REQUIRED = ['esphomeyaml', 'wifi']
 
 
 def _format_config_error(ex, domain, config):
@@ -173,6 +274,9 @@ def _format_config_error(ex, domain, config):
     else:
         message += u'{}.'.format(humanize_error(config, ex))
 
+    if isinstance(config, list):
+        return message
+
     domain_config = config.get(domain, config)
     message += u" (See {}, line {}). ".format(
         getattr(domain_config, '__config_file__', '?'),
@@ -186,46 +290,20 @@ def load_config(path):
         config = yaml_util.load_yaml(path)
     except OSError:
         raise ESPHomeYAMLError(u"Could not read configuration file at {}".format(path))
-
-    esp_platform = unicode(config.get(CONF_ESPHOMEYAML, {}).get(CONF_PLATFORM, u""))
-    esp_platform = esp_platform.upper()
-    if esp_platform not in (ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266):
-        raise ESPHomeYAMLError(u"Invalid ESP Platform {}".format(esp_platform))
-    cv.ESP_PLATFORM = esp_platform
-    cv.BOARD = unicode(config.get(CONF_ESPHOMEYAML, {}).get(CONF_BOARD, u""))
-    helpers.SIMPLIFY = cv.boolean(config.get(CONF_SIMPLIFY, True))
+    core.RAW_CONFIG = config
+    core_config.preload_core_config(config)
 
     try:
         result = validate_config(config)
-    except Exception as e:
-        print(u"Unexpected exception while reading configuration:")
+    except ESPHomeYAMLError:
+        raise
+    except Exception:
+        _LOGGER.error(u"Unexpected exception while reading configuration:")
         raise
 
     return result
 
 
-def add_platform_task(domain, config):
-    platform_ = config[CONF_PLATFORM]
-    platform = get_platform(domain, platform_)
-    if not hasattr(platform, 'to_code'):
-        raise ESPHomeYAMLError(u"Platform '{}.{}' doesn't have to_code.".format(domain, platform_))
-    add_task(platform.to_code, config)
-
-
-def add_component_task(domain, config):
-    if domain == CONF_ESPHOMEYAML:
-        add_task(core_to_code, config)
-        return
-    component = get_component(domain)
-    if is_platform_component(component):
-        for conf in config:
-            add_platform_task(domain, conf)
-    else:
-        if not hasattr(component, 'to_code'):
-            raise ESPHomeYAMLError(u"Component '{}' doesn't have to_code.".format(domain))
-        add_task(component.to_code, config)
-
-
 def line_info(obj, **kwargs):
     """Display line config source."""
     if hasattr(obj, '__config_file__'):
@@ -247,34 +325,39 @@ def dump_dict(layer, indent_count=3, listi=False, **kwargs):
     if isinstance(layer, dict):
         for key, value in sorted(layer.items(), key=sort_dict_key):
             if isinstance(value, (dict, list)):
-                print(indent_str, key + ':', line_info(value, **kwargs))
+                safe_print(u"{} {}: {}".format(indent_str, key, line_info(value, **kwargs)))
                 dump_dict(value, indent_count + 2)
             else:
-                print(indent_str, key + ':', value)
+                safe_print(u"{} {}: {}".format(indent_str, key, value))
             indent_str = indent_count * ' '
     if isinstance(layer, (list, tuple)):
         for i in layer:
             if isinstance(i, dict):
                 dump_dict(i, indent_count + 2, True)
             else:
-                print(' ', indent_str, i)
+                safe_print(u" {} {}".format(indent_str, i))
 
 
 def read_config(path):
-    _LOGGER.debug("Reading configuration...")
-    res = load_config(path)
+    _LOGGER.info("Reading configuration...")
+    try:
+        res = load_config(path)
+    except ESPHomeYAMLError as err:
+        _LOGGER.error(u"Error while reading config: %s", err)
+        return None
     excepts = {}
-    for err in res.errors:
-        domain = err[1] or u"General Error"
-        excepts.setdefault(domain, []).append(err[0])
-        if err[2] is not None:
-            excepts[domain].append(err[2])
+    for message, domain, config in res.errors:
+        domain = domain or u"General Error"
+        excepts.setdefault(domain, []).append(message)
+        if config is not None:
+            excepts[domain].append(config)
 
     if excepts:
-        print(color('bold_white', u"Failed config"))
+        safe_print(color('bold_white', u"Failed config"))
         for domain, config in excepts.iteritems():
-            print(' ', color('bold_red', domain + ':'), color('red', '', reset='red'))
+            safe_print(u' {} {}'.format(color('bold_red', domain + u':'),
+                                        color('red', '', reset='red')))
             dump_dict(config, reset='red')
-            print(color('reset'))
+            safe_print(color('reset'))
         return None
-    return dict(**res)
+    return OrderedDict(res)

esphomeyaml/config_validation.py

@@ -3,29 +3,31 @@
 from __future__ import print_function
 
 import logging
-from datetime import timedelta
+import os
+import re
+import uuid as uuid_
 
 import voluptuous as vol
 
+from esphomeyaml import core, helpers
 from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_ID, \
     CONF_NAME, CONF_PAYLOAD_AVAILABLE, \
     CONF_PAYLOAD_NOT_AVAILABLE, CONF_PLATFORM, CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC, \
-    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
-from esphomeyaml.core import HexInt, IPAddress
-from esphomeyaml.helpers import ensure_unique_string
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, CONF_INTERNAL, CONF_SETUP_PRIORITY
+from esphomeyaml.core import HexInt, IPAddress, Lambda, TimePeriod, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds
 
 _LOGGER = logging.getLogger(__name__)
 
+# pylint: disable=invalid-name
+
 port = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
 positive_float = vol.All(vol.Coerce(float), vol.Range(min=0))
-zero_to_one_float = vol.All(vol.Coerce(float), vol.Range(min=0, max=1)),
+zero_to_one_float = vol.All(vol.Coerce(float), vol.Range(min=0, max=1))
 positive_int = vol.All(vol.Coerce(int), vol.Range(min=0))
 positive_not_null_int = vol.All(vol.Coerce(int), vol.Range(min=0, min_included=False))
 
-ESP_PLATFORM = ''
-BOARD = ''
-
-ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
+ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyz0123456789_'
 
 RESERVED_IDS = [
     # C++ keywords http://en.cppreference.com/w/cpp/keyword
@@ -56,8 +58,10 @@ def alphanumeric(value):
 
 def valid_name(value):
     value = string_strict(value)
-    if not all(c in ALLOWED_NAME_CHARS for c in value):
-        raise vol.Invalid(u"Valid characters for name are %s", ALLOWED_NAME_CHARS)
+    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"".format(c, ALLOWED_NAME_CHARS))
     return value
 
 
@@ -71,7 +75,7 @@ def string(value):
 
 def string_strict(value):
     """Strictly only allow strings."""
-    if isinstance(value, str) or isinstance(value, unicode):
+    if isinstance(value, (str, unicode)):
         return value
     raise vol.Invalid("Must be string, did you forget putting quotes "
                       "around the value?")
@@ -99,13 +103,19 @@ def boolean(value):
 
 def ensure_list(value):
     """Wrap value in list if it is not one."""
-    if value is None:
+    if value is None or (isinstance(value, dict) and not value):
         return []
     if isinstance(value, list):
         return value
     return [value]
 
 
+def ensure_list_not_empty(value):
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
 def ensure_dict(value):
     if value is None:
         return {}
@@ -133,23 +143,62 @@ def int_(value):
 
 
 hex_int = vol.Coerce(hex_int_)
-match_cpp_var_ = vol.Match(r'^[a-zA-Z_][a-zA-Z0-9_]+$', msg=u"Must be a valid C++ variable name")
 
 
-def variable_id(value):
-    value = match_cpp_var_(value)
+def variable_id_str_(value):
+    value = string(value)
+    if not value:
+        raise vol.Invalid("ID must not be empty")
+    if value[0].isdigit():
+        raise vol.Invalid("First character in ID cannot be a digit.")
+    if '-' in value:
+        raise vol.Invalid("Dashes are not supported in IDs, please use underscores instead.")
+    for char in value:
+        if char != '_' and not char.isalnum():
+            raise vol.Invalid(u"IDs must only consist of upper/lowercase characters and numbers."
+                              u"The character '{}' cannot be used".format(char))
     if value in RESERVED_IDS:
         raise vol.Invalid(u"ID {} is reserved internally and cannot be used".format(value))
     return value
 
 
+def use_variable_id(type):
+    def validator(value):
+        if value is None:
+            return core.ID(None, is_declaration=False, type=type)
+
+        return core.ID(variable_id_str_(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(variable_id_str_(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 vol.Schema(other_validators)(value)
+        return other_validators(value)
+
+    return validator
+
+
 def only_on(platforms):
     if not isinstance(platforms, list):
         platforms = [platforms]
 
     def validator_(obj):
-        print(obj)
-        if ESP_PLATFORM not in platforms:
+        if core.ESP_PLATFORM not in platforms:
             raise vol.Invalid(u"This feature is only available on {}".format(platforms))
         return obj
 
@@ -170,90 +219,216 @@ def has_at_least_one_key(*keys):
         if not isinstance(obj, dict):
             raise vol.Invalid('expected dictionary')
 
-        for k in obj.keys():
-            if k in keys:
-                return obj
-        raise vol.Invalid('must contain one of {}.'.format(', '.join(keys)))
+        if not any(k in keys for k in obj):
+            raise vol.Invalid('Must contain at least one of {}.'.format(', '.join(keys)))
+        return obj
 
     return validate
 
 
-TIME_PERIOD_ERROR = "Time period {} should be format 5ms, 5s, 5min, 5h"
+def has_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, vol.Schema({
-        'days': vol.Coerce(int),
-        'hours': vol.Coerce(int),
-        'minutes': vol.Coerce(int),
-        'seconds': vol.Coerce(int),
-        'milliseconds': vol.Coerce(int),
+        'days': vol.Coerce(float),
+        'hours': vol.Coerce(float),
+        'minutes': vol.Coerce(float),
+        'seconds': vol.Coerce(float),
+        'milliseconds': vol.Coerce(float),
+        'microseconds': vol.Coerce(float),
     }),
     has_at_least_one_key('days', 'hours', 'minutes',
-                         'seconds', 'milliseconds'),
-    lambda value: timedelta(**value))
+                         'seconds', 'milliseconds', 'microseconds'),
+    lambda value: TimePeriod(**value))
 
 
-def time_period_str(value):
-    """Validate and transform time offset."""
+def time_period_str_colon(value):
+    """Validate and transform time offset with format HH:MM[:SS]."""
     if isinstance(value, int):
-        raise vol.Invalid("Make sure you wrap time values in quotes")
-    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid('Make sure you wrap time values in quotes')
+    elif not isinstance(value, str):
         raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
 
-    value = unicode(value)
-    if value.endswith(u'ms'):
-        return vol.Coerce(int)(value[:-2])
-    elif value.endswith(u's'):
-        return vol.Coerce(float)(value[:-1]) * 1000
-    elif value.endswith(u'min'):
-        return vol.Coerce(float)(value[:-3]) * 1000 * 60
-    elif value.endswith(u'h'):
-        return vol.Coerce(float)(value[:-1]) * 1000 * 60 * 60
-    raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
-
-
-def time_period_milliseconds(value):
     try:
-        return timedelta(milliseconds=int(value))
-    except (ValueError, TypeError):
-        raise vol.Invalid('Expected milliseconds, got {}'.format(value))
+        parsed = [int(x) for x in value.split(':')]
+    except ValueError:
+        raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+    if len(parsed) == 2:
+        hour, minute = parsed
+        second = 0
+    elif len(parsed) == 3:
+        hour, minute, second = parsed
+    else:
+        raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
+
+    return TimePeriod(hours=hour, minutes=minute, seconds=second)
 
 
-def time_period_to_milliseconds(value):
-    if isinstance(value, (int, long)):
-        return value
-    if isinstance(value, float):
-        return int(value)
-    return value / timedelta(milliseconds=1)
+def time_period_str_unit(value):
+    """Validate and transform time period with time unit and integer value."""
+    if isinstance(value, int):
+        raise vol.Invalid("Don't know what '{}' means as it has no time *unit*! Did you mean "
+                          "'{}s'?".format(value, value))
+    elif not isinstance(value, (str, unicode)):
+        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 or match.group(2) not in unit_to_kwarg:
+        raise vol.Invalid(u"Expected time period with unit, "
+                          u"got {}".format(value))
+
+    kwarg = unit_to_kwarg[match.group(2)]
+    return TimePeriod(**{kwarg: float(match.group(1))})
 
 
-time_period = vol.All(vol.Any(time_period_str, timedelta, time_period_dict,
-                              time_period_milliseconds), time_period_to_milliseconds)
-positive_time_period = vol.All(time_period, vol.Range(min=0))
-positive_not_null_time_period = vol.All(time_period, vol.Range(min=0, min_included=False))
+def time_period_in_milliseconds_(value):
+    if value.microseconds is not None and value.microseconds != 0:
+        raise vol.Invalid("Maximum precision is milliseconds")
+    return TimePeriodMilliseconds(**value.as_dict())
+
+
+def time_period_in_microseconds_(value):
+    return TimePeriodMicroseconds(**value.as_dict())
+
+
+def time_period_in_seconds_(value):
+    if value.microseconds is not None and value.microseconds != 0:
+        raise vol.Invalid("Maximum precision is seconds")
+    if value.milliseconds is not None and value.milliseconds != 0:
+        raise vol.Invalid("Maximum precision is seconds")
+    return TimePeriodSeconds(**value.as_dict())
+
+
+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_)
+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 frequency(value):
-    value = string(value).replace(' ', '').lower()
-    if value.endswith('Hz') or value.endswith('hz') or value.endswith('HZ'):
-        value = value[:-2]
-    if not value:
-        raise vol.Invalid(u"Frequency must have value")
-    multiplier = 1
-    if value[:-1] in METRIC_SUFFIXES:
-        multiplier = METRIC_SUFFIXES[value[:-1]]
-        value = value[:-1]
-    elif len(value) >= 2 and value[:-2] in METRIC_SUFFIXES:
-        multiplier = METRIC_SUFFIXES[value[:-2]]
-        value = value[:-2]
-    float_val = vol.Coerce(float)(value)
-    return float_val * multiplier
+def 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)?")
+
+
+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):
@@ -266,6 +441,18 @@ def hostname(value):
     return value
 
 
+def domain_name(value):
+    value = string(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):
     if value is None:
         raise vol.Invalid("SSID can not be None")
@@ -273,8 +460,8 @@ def ssid(value):
         raise vol.Invalid("SSID must be a string. Did you wrap it in quotes?")
     if not value:
         raise vol.Invalid("SSID can't be empty.")
-    if len(value) > 32:
-        raise vol.Invalid("SSID can't be longer than 32 characters")
+    if len(value) > 31:
+        raise vol.Invalid("SSID can't be longer than 31 characters")
     return value
 
 
@@ -295,15 +482,70 @@ def ipv4(value):
     return IPAddress(*parts_)
 
 
-def publish_topic(value):
-    value = string_strict(value)
-    if value.endswith('/'):
-        raise vol.Invalid("Publish topic can't end with '/'")
+def _valid_topic(value):
+    """Validate that this is a valid topic name/filter."""
+    if isinstance(value, dict):
+        raise vol.Invalid("Can't use dictionary with topic")
+    value = string(value)
+    try:
+        raw_value = value.encode('utf-8')
+    except UnicodeError:
+        raise vol.Invalid("MQTT topic name/filter must be valid UTF-8 string.")
+    if not raw_value:
+        raise vol.Invalid("MQTT topic name/filter must not be empty.")
+    if len(raw_value) > 65535:
+        raise vol.Invalid("MQTT topic name/filter must not be longer than "
+                          "65535 encoded bytes.")
+    if '\0' in value:
+        raise vol.Invalid("MQTT topic name/filter must not contain null "
+                          "character.")
     return value
 
 
-subscribe_topic = string_strict  # TODO improve this
-mqtt_payload = string  # TODO improve this
+def subscribe_topic(value):
+    """Validate that we can subscribe using this MQTT topic."""
+    value = _valid_topic(value)
+    for i in (i for i, c in enumerate(value) if c == '+'):
+        if (i > 0 and value[i - 1] != '/') or \
+                (i < len(value) - 1 and value[i + 1] != '/'):
+            raise vol.Invalid("Single-level wildcard must occupy an entire "
+                              "level of the filter")
+
+    index = value.find('#')
+    if index != -1:
+        if index != len(value) - 1:
+            # If there are multiple wildcards, this will also trigger
+            raise vol.Invalid("Multi-level wildcard must be the last "
+                              "character in the topic filter.")
+        if len(value) > 1 and value[index - 1] != '/':
+            raise vol.Invalid("Multi-level wildcard must be after a topic "
+                              "level separator.")
+
+    return value
+
+
+def publish_topic(value):
+    """Validate that we can publish using this MQTT topic."""
+    value = _valid_topic(value)
+    if '+' in value or '#' in value:
+        raise vol.Invalid("Wildcards can not be used in topic names")
+    return value
+
+
+def mqtt_payload(value):
+    if value is None:
+        return ''
+    return string(value)
+
+
+def mqtt_qos(value):
+    try:
+        value = int(value)
+    except (TypeError, ValueError):
+        raise vol.Invalid(u"MQTT Quality of Service must be integer, got {}".format(value))
+    return one_of(0, 1, 2)(value)
+
+
 uint8_t = vol.All(int_, vol.Range(min=0, max=255))
 uint16_t = vol.All(int_, vol.Range(min=0, max=65535))
 uint32_t = vol.All(int_, vol.Range(min=0, max=4294967295))
@@ -313,43 +555,115 @@ hex_uint32_t = vol.All(hex_int, vol.Range(min=0, max=4294967295))
 i2c_address = hex_uint8_t
 
 
-def invalid(value):
-    raise vol.Invalid("This shouldn't happen.")
+def percentage(value):
+    has_percent_sign = isinstance(value, (str, unicode)) 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)
+    return zero_to_one_float(value)
+
+
+def percentage_int(value):
+    if isinstance(value, (str, unicode)) 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
 
 
-REGISTERED_IDS = set()
+def one_of(*values):
+    options = u', '.join(u"'{}'".format(x) for x in values)
+
+    def validator(value):
+        if value not in values:
+            raise vol.Invalid(u"Unknown value '{}', must be one of {}".format(value, options))
+        return value
+
+    return validator
 
 
-def register_variable_id(value):
-    s = variable_id(value)
-    if s in REGISTERED_IDS:
-        raise vol.Invalid("This ID has already been used")
-    REGISTERED_IDS.add(s)
-    return s
+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 = helpers.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 = helpers.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
 
 
 class GenerateID(vol.Optional):
-    def __init__(self, basename):
-        self._basename = basename
-        super(GenerateID, self).__init__(CONF_ID, default=self.default_variable_id)
-
-    def default_variable_id(self):
-        return ensure_unique_string(self._basename, REGISTERED_IDS)
+    def __init__(self, key=CONF_ID):
+        super(GenerateID, self).__init__(key, default=lambda: None)
 
 
-ID_SCHEMA = vol.Schema({
-    vol.Required(CONF_ID): invalid,
-})
+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
 
-REQUIRED_ID_SCHEMA = vol.Schema({
-    vol.Required(CONF_ID): register_variable_id,
-})
+    return validator
 
-PLATFORM_SCHEMA = ID_SCHEMA.extend({
+
+PLATFORM_SCHEMA = vol.Schema({
     vol.Required(CONF_PLATFORM): valid,
 })
 
@@ -360,13 +674,18 @@ MQTT_COMPONENT_AVAILABILITY_SCHEMA = vol.Schema({
 })
 
 MQTT_COMPONENT_SCHEMA = vol.Schema({
-    vol.Required(CONF_NAME): string,
+    vol.Optional(CONF_NAME): string,
     vol.Optional(CONF_RETAIN): boolean,
     vol.Optional(CONF_DISCOVERY): boolean,
     vol.Optional(CONF_STATE_TOPIC): publish_topic,
-    vol.Optional(CONF_AVAILABILITY): MQTT_COMPONENT_AVAILABILITY_SCHEMA,
+    vol.Optional(CONF_AVAILABILITY): 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): subscribe_topic,
 })
+
+COMPONENT_SCHEMA = vol.Schema({
+    vol.Optional(CONF_SETUP_PRIORITY): vol.Coerce(float)
+})

esphomeyaml/const.py

@@ -1,10 +1,11 @@
 """Constants used by esphomeyaml."""
 
 MAJOR_VERSION = 1
-MINOR_VERSION = 2
-PATCH_VERSION = '1'
+MINOR_VERSION = 9
+PATCH_VERSION = '3'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
+ESPHOMELIB_VERSION = '1.9.3'
 
 ESP_PLATFORM_ESP32 = 'ESP32'
 ESP_PLATFORM_ESP8266 = 'ESP8266'
@@ -16,8 +17,14 @@ CONF_ESPHOMEYAML = 'esphomeyaml'
 CONF_NAME = 'name'
 CONF_PLATFORM = 'platform'
 CONF_BOARD = 'board'
-CONF_SIMPLIFY = 'simplify'
-CONF_LIBRARY_URI = 'library_uri'
+CONF_ESPHOMELIB_VERSION = 'esphomelib_version'
+CONF_USE_CUSTOM_CODE = 'use_custom_code'
+CONF_ARDUINO_VERSION = 'arduino_version'
+CONF_LOCAL = 'local'
+CONF_REPOSITORY = 'repository'
+CONF_COMMIT = 'commit'
+CONF_TAG = 'tag'
+CONF_BRANCH = 'branch'
 CONF_LOGGER = 'logger'
 CONF_WIFI = 'wifi'
 CONF_SSID = 'ssid'
@@ -32,6 +39,14 @@ CONF_BROKER = 'broker'
 CONF_USERNAME = 'username'
 CONF_POWER_SUPPLY = 'power_supply'
 CONF_ID = 'id'
+CONF_MQTT_ID = 'mqtt_id'
+CONF_SENSOR_ID = 'sensor_id'
+CONF_TRIGGER_ID = 'trigger_id'
+CONF_ACTION_ID = 'action_id'
+CONF_CONDITION_ID = 'condition_id'
+CONF_MAKE_ID = 'make_id'
+CONF_AUTOMATION_ID = 'automation_id'
+CONF_DELAY = 'delay'
 CONF_PIN = 'pin'
 CONF_NUMBER = 'number'
 CONF_INVERTED = 'inverted'
@@ -68,6 +83,15 @@ CONF_TOPIC = 'topic'
 CONF_PAYLOAD_AVAILABLE = 'payload_available'
 CONF_PAYLOAD_NOT_AVAILABLE = 'payload_not_available'
 CONF_DEFAULT_TRANSITION_LENGTH = 'default_transition_length'
+CONF_TRANSITION_LENGTH = 'transition_length'
+CONF_FLASH_LENGTH = 'flash_length'
+CONF_BRIGHTNESS = 'brightness'
+CONF_EFFECT = 'effect'
+CONF_ABOVE = 'above'
+CONF_BELOW = 'below'
+CONF_ON = 'on'
+CONF_IF = 'if'
+CONF_THEN = 'then'
 CONF_BINARY = 'binary'
 CONF_WHITE = 'white'
 CONF_RGBW = 'rgbw'
@@ -81,6 +105,7 @@ 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'
@@ -107,6 +132,14 @@ CONF_WINDOW_SIZE = 'window_size'
 CONF_SEND_EVERY = 'send_every'
 CONF_ALPHA = 'alpha'
 CONF_LAMBDA = 'lambda'
+CONF_THROTTLE = 'throttle'
+CONF_DELTA = 'delta'
+CONF_OR = 'or'
+CONF_AND = 'and'
+CONF_RANGE = 'range'
+CONF_UNIQUE = 'unique'
+CONF_HEARTBEAT = 'heartbeat'
+CONF_DEBOUNCE = 'debounce'
 CONF_UPDATE_INTERVAL = 'update_interval'
 CONF_PULL_MODE = 'pull_mode'
 CONF_COUNT_MODE = 'count_mode'
@@ -122,22 +155,23 @@ CONF_TRIGGER_PIN = 'trigger_pin'
 CONF_ECHO_PIN = 'echo_pin'
 CONF_TIMEOUT_METER = 'timeout_meter'
 CONF_TIMEOUT_TIME = 'timeout_time'
-CONF_IR_TRANSMITTER_ID = 'ir_transmitter_id'
 CONF_CARRIER_DUTY_PERCENT = 'carrier_duty_percent'
 CONF_NEC = 'nec'
 CONF_COMMAND = 'command'
 CONF_DATA = 'data'
 CONF_NBITS = 'nbits'
 CONF_LG = 'lg'
+CONF_SAMSUNG = 'samsung'
 CONF_SONY = 'sony'
 CONF_PANASONIC = 'panasonic'
 CONF_REPEAT = 'repeat'
 CONF_TIMES = 'times'
-CONF_WAIT_TIME_US = 'wait_time_us'
+CONF_WAIT_TIME = 'wait_time'
 CONF_OSCILLATION_OUTPUT = 'oscillation_output'
 CONF_SPEED = 'speed'
 CONF_OSCILLATION_STATE_TOPIC = 'oscillation_state_topic'
 CONF_OSCILLATION_COMMAND_TOPIC = 'oscillation_command_topic'
+CONF_OSCILLATING = 'oscillating'
 CONF_SPEED_STATE_TOPIC = 'speed_state_topic'
 CONF_SPEED_COMMAND_TOPIC = 'speed_command_topic'
 CONF_LOW = 'low'
@@ -151,25 +185,195 @@ CONF_RATE = 'rate'
 CONF_ADS1115_ID = 'ads1115_id'
 CONF_MULTIPLEXER = 'multiplexer'
 CONF_GAIN = 'gain'
+CONF_SLEEP_DURATION = 'sleep_duration'
+CONF_WAKEUP_PIN = 'wakeup_pin'
+CONF_RUN_CYCLES = 'run_cycles'
+CONF_RUN_DURATION = 'run_duration'
+CONF_AP = 'ap'
+CONF_CSS_URL = 'css_url'
+CONF_JS_URL = 'js_url'
+CONF_SSL_FINGERPRINTS = 'ssl_fingerprints'
+CONF_PCF8574 = 'pcf8574'
+CONF_PCF8575 = 'pcf8575'
+CONF_SCAN = 'scan'
+CONF_KEEPALIVE = 'keepalive'
+CONF_INTEGRATION_TIME = 'integration_time'
+CONF_RECEIVE_TIMEOUT = 'receive_timeout'
+CONF_SCAN_INTERVAL = 'scan_interval'
+CONF_MAC_ADDRESS = 'mac_address'
+CONF_SETUP_MODE = 'setup_mode'
+CONF_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_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_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_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_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_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_WARM_WHITE = 'warm_white'
+CONF_COLD_WHITE_COLOR_TEMPERATURE = 'cold_white_color_temperature'
+CONF_WARM_WHITE_COLOR_TEMPERATURE = 'warm_white_color_temperature'
+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_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'
 
-ESP32_BOARDS = [
-    'featheresp32', 'node32s', 'espea32', 'firebeetle32', 'esp32doit-devkit-v1',
-    'pocket_32', 'espectro32', 'esp32vn-iot-uno', 'esp320', 'esp-wrover-kit',
-    'esp32dev', 'heltec_wifi_kit32', 'heltec_wifi_lora_32', 'hornbill32dev',
-    'hornbill32minima', 'intorobot', 'm5stack-core-esp32', 'mhetesp32devkit',
-    'mhetesp32minikit', 'nano32', 'microduino-core-esp32', 'nodemcu-32s',
-    'quantum', 'esp32-evb', 'esp32-gateway', 'onehorse32dev', 'esp32thing',
-    'espino32', 'lolin32', 'wemosbat', 'widora-air', 'nina_w10',
-]
 
-ESP8266_BOARDS = [
-    'gen4iod', 'huzzah', 'oak', 'espduino', 'espectro', 'espresso_lite_v1',
-    'espresso_lite_v2', 'espino', 'esp01', 'esp01_1m', 'esp07', 'esp12e', 'esp8285',
-    'esp_wroom_02', 'phoenix_v1', 'phoenix_v2', 'wifinfo', 'heltex_wifi_kit_8',
-    'nodemcu', 'nodemcuv2', 'modwifi', 'wio_node', 'sparkfunBlynk', 'thing',
-    'thingdev', 'esp210', 'espinotee', 'd1', 'd1_mini', 'd1_mini_lite', 'd1_mini_pro',
-]
-ESP_BOARDS_FOR_PLATFORM = {
-    ESP_PLATFORM_ESP32: ESP32_BOARDS,
-    ESP_PLATFORM_ESP8266: ESP8266_BOARDS
-}
+ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyz0123456789_'
+ARDUINO_VERSION_ESP32_DEV = 'https://github.com/platformio/platform-espressif32.git#feature/stage'
+ARDUINO_VERSION_ESP8266_DEV = 'https://github.com/platformio/platform-espressif8266.git#feature' \
+                              '/stage'

esphomeyaml/core.py

@@ -1,3 +1,8 @@
+import math
+import re
+from collections import OrderedDict
+
+
 class ESPHomeYAMLError(Exception):
     """General esphomeyaml exception occurred."""
     pass
@@ -5,6 +10,8 @@ class ESPHomeYAMLError(Exception):
 
 class HexInt(long):
     def __str__(self):
+        if 0 <= self <= 255:
+            return "0x{:02X}".format(self)
         return "0x{:X}".format(self)
 
 
@@ -16,3 +23,238 @@ class IPAddress(object):
 
     def __str__(self):
         return '.'.join(str(x) for x in self.args)
+
+
+class MACAddress(object):
+    def __init__(self, *parts):
+        if len(parts) != 6:
+            raise ValueError(u"MAC Address must consist of 6 items")
+        self.parts = parts
+
+    def __str__(self):
+        return ':'.join('{:02X}'.format(part) for part in self.parts)
+
+    def as_hex(self):
+        import esphomeyaml.helpers
+
+        num = ''.join('{:02X}'.format(part) for part in self.parts)
+        return esphomeyaml.helpers.RawExpression('0x{}ULL'.format(num))
+
+
+def is_approximately_integer(value):
+    if isinstance(value, (int, long)):
+        return True
+    return abs(value - round(value)) < 0.001
+
+
+class TimePeriod(object):
+    def __init__(self, microseconds=None, milliseconds=None, seconds=None,
+                 minutes=None, hours=None, days=None):
+        if days is not None:
+            if not is_approximately_integer(days):
+                frac_days, days = math.modf(days)
+                hours = (hours or 0) + frac_days * 24
+            self.days = int(round(days))
+        else:
+            self.days = None
+
+        if hours is not None:
+            if not is_approximately_integer(hours):
+                frac_hours, hours = math.modf(hours)
+                minutes = (minutes or 0) + frac_hours * 60
+            self.hours = int(round(hours))
+        else:
+            self.hours = None
+
+        if minutes is not None:
+            if not is_approximately_integer(minutes):
+                frac_minutes, minutes = math.modf(minutes)
+                seconds = (seconds or 0) + frac_minutes * 60
+            self.minutes = int(round(minutes))
+        else:
+            self.minutes = None
+
+        if seconds is not None:
+            if not is_approximately_integer(seconds):
+                frac_seconds, seconds = math.modf(seconds)
+                milliseconds = (milliseconds or 0) + frac_seconds * 1000
+            self.seconds = int(round(seconds))
+        else:
+            self.seconds = None
+
+        if milliseconds is not None:
+            if not is_approximately_integer(milliseconds):
+                frac_milliseconds, milliseconds = math.modf(milliseconds)
+                microseconds = (microseconds or 0) + frac_milliseconds * 1000
+            self.milliseconds = int(round(milliseconds))
+        else:
+            self.milliseconds = None
+
+        if microseconds is not None:
+            if not is_approximately_integer(microseconds):
+                raise ValueError("Maximum precision is microseconds")
+            self.microseconds = int(round(microseconds))
+        else:
+            self.microseconds = None
+
+    def as_dict(self):
+        out = OrderedDict()
+        if self.microseconds is not None:
+            out['microseconds'] = self.microseconds
+        if self.milliseconds is not None:
+            out['milliseconds'] = self.milliseconds
+        if self.seconds is not None:
+            out['seconds'] = self.seconds
+        if self.minutes is not None:
+            out['minutes'] = self.minutes
+        if self.hours is not None:
+            out['hours'] = self.hours
+        if self.days is not None:
+            out['days'] = self.days
+        return out
+
+    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 Lambda(object):
+    def __init__(self, value):
+        self.value = value
+        self.parts = re.split(r'id\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)', value)
+        self.requires_ids = [ID(self.parts[i]) for i in range(1, len(self.parts), 3)]
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return u'Lambda<{}>'.format(self.value)
+
+
+def ensure_unique_string(preferred_string, current_strings):
+    test_string = preferred_string
+    current_strings_set = set(current_strings)
+
+    tries = 1
+
+    while test_string in current_strings_set:
+        tries += 1
+        test_string = u"{}_{}".format(preferred_string, tries)
+
+    return test_string
+
+
+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):
+        if self.id is None:
+            base = str(self.type).replace('::', '_').lower()
+            name = ''.join(c for c in base if c.isalnum() or c == '_')
+            self.id = ensure_unique_string(name, registered_ids)
+        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)
+
+
+CONFIG_PATH = None
+ESP_PLATFORM = ''
+BOARD = ''
+RAW_CONFIG = None
+NAME = ''

esphomeyaml/core_config.py

@@ -0,0 +1,267 @@
+import logging
+import os
+import re
+import subprocess
+
+import voluptuous as vol
+
+from esphomeyaml import automation, core, pins
+import esphomeyaml.config_validation as cv
+from esphomeyaml.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_ESPHOMELIB_VERSION, CONF_ESPHOMEYAML, CONF_LOCAL, CONF_NAME, CONF_ON_BOOT, \
+    CONF_ON_LOOP, CONF_ON_SHUTDOWN, CONF_PLATFORM, CONF_PRIORITY, CONF_REPOSITORY, CONF_TAG, \
+    CONF_TRIGGER_ID, CONF_USE_CUSTOM_CODE, ESPHOMELIB_VERSION, ESP_PLATFORM_ESP32, \
+    ESP_PLATFORM_ESP8266
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, NoArg, Pvariable, RawExpression, add, const_char_p, \
+    esphomelib_ns, relative_path
+from esphomeyaml.util import safe_print
+
+_LOGGER = logging.getLogger(__name__)
+
+LIBRARY_URI_REPO = u'https://github.com/OttoWinter/esphomelib.git'
+
+BUILD_FLASH_MODES = ['qio', 'qout', 'dio', 'dout']
+StartupTrigger = esphomelib_ns.StartupTrigger
+ShutdownTrigger = esphomelib_ns.ShutdownTrigger
+LoopTrigger = esphomelib_ns.LoopTrigger
+
+VERSION_REGEX = re.compile(r'^[0-9]+\.[0-9]+\.[0-9]+(?:-beta)?(?:-alpha)?$')
+
+
+def validate_board(value):
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+        board_pins = pins.ESP8266_BOARD_PINS
+    elif core.ESP_PLATFORM == ESP_PLATFORM_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_esphomelib_version(value):
+    value = cv.string_strict(value)
+    if value.upper() == 'LATEST':
+        if ESPHOMELIB_VERSION == 'dev':
+            return validate_simple_esphomelib_version('dev')
+        return {
+            CONF_REPOSITORY: LIBRARY_URI_REPO,
+            CONF_TAG: 'v' + ESPHOMELIB_VERSION,
+        }
+    elif value.upper() == 'DEV':
+        return {
+            CONF_REPOSITORY: LIBRARY_URI_REPO,
+            CONF_BRANCH: 'dev'
+        }
+    elif VERSION_REGEX.match(value) is not None:
+        return {
+            CONF_REPOSITORY: LIBRARY_URI_REPO,
+            CONF_TAG: 'v' + value,
+        }
+    raise vol.Invalid("Only simple esphomelib versions!")
+
+
+def validate_local_esphomelib_version(value):
+    value = cv.directory(value)
+    path = 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"esphomelib 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
+
+
+ESPHOMELIB_VERSION_SCHEMA = vol.Any(
+    validate_simple_esphomelib_version,
+    vol.Schema({
+        vol.Required(CONF_LOCAL): validate_local_esphomelib_version,
+    }),
+    vol.All(
+        vol.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.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',
+    'RECOMMENDED': 'espressif32@>=1.4.0',
+    'LATEST': 'espressif32',
+    'DEV': ARDUINO_VERSION_ESP32_DEV,
+}
+
+
+def validate_arduino_version(value):
+    value = cv.string_strict(value)
+    value_ = value.upper()
+    if core.ESP_PLATFORM == ESP_PLATFORM_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
+    elif core.ESP_PLATFORM == ESP_PLATFORM_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
+    else:
+        raise NotImplementedError
+
+
+def default_build_path():
+    return core.NAME
+
+
+CONFIG_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.valid_name,
+    vol.Required(CONF_PLATFORM): vol.All(vol.Upper, cv.one_of('ESP8266', 'ESPRESSIF8266',
+                                                              'ESP32', 'ESPRESSIF32')),
+    vol.Required(CONF_BOARD): validate_board,
+    vol.Optional(CONF_ESPHOMELIB_VERSION, default='latest'): ESPHOMELIB_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_BOARD_FLASH_MODE): vol.All(vol.Lower, cv.one_of(*BUILD_FLASH_MODES)),
+    vol.Optional(CONF_ON_BOOT): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StartupTrigger),
+        vol.Optional(CONF_PRIORITY): vol.Coerce(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('library_uri'): cv.invalid("The library_uri option has been removed in 1.8.0 and "
+                                            "was moved into the esphomelib_version option."),
+    vol.Optional('use_build_flags'): cv.invalid("The use_build_flags option has been replaced by "
+                                                "use_custom_code option in 1.8.0."),
+})
+
+
+def preload_core_config(config):
+    if CONF_ESPHOMEYAML not in config:
+        raise ESPHomeYAMLError(u"No esphomeyaml section in config")
+    core_conf = config[CONF_ESPHOMEYAML]
+    if CONF_PLATFORM not in core_conf:
+        raise ESPHomeYAMLError("esphomeyaml.platform not specified.")
+    if CONF_BOARD not in core_conf:
+        raise ESPHomeYAMLError("esphomeyaml.board not specified.")
+    if CONF_NAME not in core_conf:
+        raise ESPHomeYAMLError("esphomeyaml.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])
+    except vol.Invalid as e:
+        raise ESPHomeYAMLError(unicode(e))
+
+
+def run_command(*args):
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout, stderr = p.communicate()
+    rc = p.returncode
+    return rc, stdout, stderr
+
+
+def update_esphomelib_repo(config):
+    esphomelib_version = config[CONF_ESPHOMELIB_VERSION]
+    if CONF_REPOSITORY not in esphomelib_version:
+        return
+
+    build_path = relative_path(config[CONF_BUILD_PATH])
+    esphomelib_path = os.path.join(build_path, '.piolibdeps', 'esphomelib')
+    is_default_branch = all(x not in esphomelib_version
+                            for x in (CONF_BRANCH, CONF_TAG, CONF_COMMIT))
+    if not (CONF_BRANCH in esphomelib_version or is_default_branch):
+        # Git commit hash or tag cannot be updated
+        return
+
+    rc, _, _ = run_command('git', '-C', esphomelib_path, '--help')
+    if rc != 0:
+        # git not installed or repo not downloaded yet
+        return
+    rc, _, _ = run_command('git', '-C', esphomelib_path, 'diff-index', '--quiet', 'HEAD', '--')
+    if rc != 0:
+        # local changes, cannot update
+        _LOGGER.warn("Local changes in esphomelib copy from git. Will not auto-update.")
+        return
+    _LOGGER.info("Updating esphomelib copy from git (%s)", esphomelib_path)
+    rc, stdout, _ = run_command('git', '-c', 'color.ui=always', '-C', esphomelib_path,
+                                'pull', '--stat')
+    if rc != 0:
+        _LOGGER.warn("Couldn't auto-update local git copy of esphomelib.")
+        return
+    stdout = stdout.strip()
+    if 'Already up to date' in stdout:
+        return
+    safe_print(stdout)
+
+
+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_automation(trigger, NoArg, conf)
+
+    for conf in config.get(CONF_ON_SHUTDOWN, []):
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], ShutdownTrigger.new())
+        automation.build_automation(trigger, const_char_p, conf)
+
+    for conf in config.get(CONF_ON_LOOP, []):
+        rhs = App.register_component(LoopTrigger.new())
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, NoArg, conf)
+
+    update_esphomelib_repo(config)
+
+    add(App.set_compilation_datetime(RawExpression('__DATE__ ", " __TIME__')))

esphomeyaml/dashboard/dashboard.py

@@ -0,0 +1,288 @@
+# pylint: disable=wrong-import-position
+from __future__ import print_function
+
+import codecs
+import hmac
+import json
+import logging
+import os
+import random
+import subprocess
+
+from esphomeyaml.const import CONF_ESPHOMEYAML, CONF_BUILD_PATH
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml import const, core, __main__
+from esphomeyaml.__main__ import get_serial_ports
+from esphomeyaml.helpers import relative_path
+from esphomeyaml.util import shlex_quote
+
+try:
+    import tornado
+    import tornado.gen
+    import tornado.ioloop
+    import tornado.iostream
+    import tornado.process
+    import tornado.web
+    import tornado.websocket
+    import tornado.concurrent
+except ImportError as err:
+    tornado = None
+
+_LOGGER = logging.getLogger(__name__)
+CONFIG_DIR = ''
+PASSWORD = ''
+
+
+# pylint: disable=abstract-method
+class BaseHandler(tornado.web.RequestHandler):
+    def is_authenticated(self):
+        return not PASSWORD or self.get_secure_cookie('authenticated') == 'yes'
+
+
+# pylint: disable=abstract-method, arguments-differ
+class EsphomeyamlCommandWebSocket(tornado.websocket.WebSocketHandler):
+    def __init__(self, application, request, **kwargs):
+        super(EsphomeyamlCommandWebSocket, self).__init__(application, request, **kwargs)
+        self.proc = None
+        self.closed = False
+
+    def on_message(self, message):
+        if PASSWORD and self.get_secure_cookie('authenticated') != 'yes':
+            return
+        if self.proc is not None:
+            return
+        command = self.build_command(message)
+        _LOGGER.debug(u"WebSocket opened for command %s", [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:
+                data = yield self.proc.stdout.read_until_regex('[\n\r]')
+            except tornado.iostream.StreamClosedError:
+                break
+            if data.endswith('\r') and random.randrange(100) < 90:
+                continue
+            try:
+                data = data.replace('\033', '\\033')
+            except UnicodeDecodeError:
+                data = data.encode('ascii', 'backslashreplace')
+            self.write_message({'event': 'line', 'data': data})
+
+    def proc_on_exit(self, returncode):
+        if not self.closed:
+            _LOGGER.debug("Process exited with return code %s", returncode)
+            self.write_message({'event': 'exit', 'code': returncode})
+
+    def on_close(self):
+        self.closed = True
+        if self.proc is not None and self.proc.returncode is None:
+            _LOGGER.debug("Terminating process")
+            self.proc.proc.terminate()
+
+    def build_command(self, message):
+        raise NotImplementedError
+
+
+class EsphomeyamlLogsHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = CONFIG_DIR + '/' + js['configuration']
+        return ["esphomeyaml", config_file, "logs", '--serial-port', js["port"], '--escape']
+
+
+class EsphomeyamlRunHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "run", '--upload-port', js["port"],
+                '--escape', '--use-esptoolpy']
+
+
+class EsphomeyamlCompileHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "compile"]
+
+
+class EsphomeyamlValidateHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "config"]
+
+
+class EsphomeyamlCleanMqttHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "clean-mqtt"]
+
+
+class EsphomeyamlCleanHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "clean"]
+
+
+class EsphomeyamlHassConfigHandler(EsphomeyamlCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphomeyaml", config_file, "hass-config"]
+
+
+class SerialPortRequestHandler(BaseHandler):
+    def get(self):
+        if not self.is_authenticated():
+            self.redirect('/login')
+            return
+        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'})
+        self.write(json.dumps(sorted(data, reverse=True)))
+
+
+class WizardRequestHandler(BaseHandler):
+    def post(self):
+        from esphomeyaml import wizard
+
+        if not self.is_authenticated():
+            self.redirect('/login')
+            return
+        kwargs = {k: ''.join(v) for k, v in self.request.arguments.iteritems()}
+        config = wizard.wizard_file(**kwargs)
+        destination = os.path.join(CONFIG_DIR, kwargs['name'] + '.yaml')
+        with codecs.open(destination, 'w') as f_handle:
+            f_handle.write(config)
+
+        self.redirect('/?begin=True')
+
+
+class DownloadBinaryRequestHandler(BaseHandler):
+    def get(self):
+        if not self.is_authenticated():
+            self.redirect('/login')
+            return
+
+        configuration = self.get_argument('configuration')
+        config_file = os.path.join(CONFIG_DIR, configuration)
+        core.CONFIG_PATH = config_file
+        config = __main__.read_config(core.CONFIG_PATH)
+        build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+        path = os.path.join(build_path, '.pioenvs', core.NAME, 'firmware.bin')
+        self.set_header('Content-Type', 'application/octet-stream')
+        self.set_header("Content-Disposition", 'attachment; filename="{}.bin"'.format(core.NAME))
+        with open(path, 'rb') as f:
+            while 1:
+                data = f.read(16384)  # or some other nice-sized chunk
+                if not data:
+                    break
+                self.write(data)
+        self.finish()
+
+
+class MainRequestHandler(BaseHandler):
+    def get(self):
+        if not self.is_authenticated():
+            self.redirect('/login')
+            return
+
+        begin = bool(self.get_argument('begin', False))
+        files = sorted([f for f in os.listdir(CONFIG_DIR) if f.endswith('.yaml') and
+                        not f.startswith('.')])
+        full_path_files = [os.path.join(CONFIG_DIR, f) for f in files]
+        self.render("templates/index.html", files=files, full_path_files=full_path_files,
+                    version=const.__version__, begin=begin)
+
+
+class LoginHandler(BaseHandler):
+    def get(self):
+        self.write('<html><body><form action="/login" method="post">'
+                   'Password: <input type="password" name="password">'
+                   '<input type="submit" value="Sign in">'
+                   '</form></body></html>')
+
+    def post(self):
+        password = str(self.get_argument("password", ''))
+        password = hmac.new(password).digest()
+        if hmac.compare_digest(PASSWORD, password):
+            self.set_secure_cookie("authenticated", "yes")
+        self.redirect("/")
+
+
+def make_app(debug=False):
+    static_path = os.path.join(os.path.dirname(__file__), 'static')
+    return tornado.web.Application([
+        (r"/", MainRequestHandler),
+        (r"/login", LoginHandler),
+        (r"/logs", EsphomeyamlLogsHandler),
+        (r"/run", EsphomeyamlRunHandler),
+        (r"/compile", EsphomeyamlCompileHandler),
+        (r"/validate", EsphomeyamlValidateHandler),
+        (r"/clean-mqtt", EsphomeyamlCleanMqttHandler),
+        (r"/clean", EsphomeyamlCleanHandler),
+        (r"/hass-config", EsphomeyamlHassConfigHandler),
+        (r"/download.bin", DownloadBinaryRequestHandler),
+        (r"/serial-ports", SerialPortRequestHandler),
+        (r"/wizard.html", WizardRequestHandler),
+        (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': static_path}),
+    ], debug=debug, cookie_secret=PASSWORD)
+
+
+def start_web_server(args):
+    global CONFIG_DIR
+    global PASSWORD
+
+    if tornado is None:
+        raise ESPHomeYAMLError("Attempted to load dashboard, but tornado is not installed! "
+                               "Please run \"pip2 install tornado esptool\" in your terminal.")
+
+    CONFIG_DIR = args.configuration
+    if not os.path.exists(CONFIG_DIR):
+        os.makedirs(CONFIG_DIR)
+
+    # HassIO options storage
+    PASSWORD = args.password
+    if os.path.isfile('/data/options.json'):
+        with open('/data/options.json') as f:
+            js = json.load(f)
+            PASSWORD = js.get('password') or PASSWORD
+
+    if PASSWORD:
+        PASSWORD = hmac.new(str(PASSWORD)).digest()
+        # Use the digest of the password as our cookie secret. This makes sure the cookie
+        # isn't too short. It, of course, enables local hash brute forcing (because the cookie
+        # secret can be brute forced without making requests). But the hashing algorithm used
+        # by tornado is apparently strong enough to make brute forcing even a short string pretty
+        # hard.
+
+    _LOGGER.info("Starting dashboard web server on port %s and configuration dir %s...",
+                 args.port, CONFIG_DIR)
+    app = make_app(args.verbose)
+    app.listen(args.port)
+
+    if args.open_ui:
+        import webbrowser
+
+        webbrowser.open('localhost:{}'.format(args.port))
+
+    try:
+        tornado.ioloop.IOLoop.current().start()
+    except KeyboardInterrupt:
+        _LOGGER.info("Shutting down...")

esphomeyaml/dashboard/templates/index.html

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

esphomeyaml/espota.py

@@ -43,6 +43,8 @@ import random
 import socket
 import sys
 
+# pylint: disable=no-member
+
 # Commands
 FLASH = 0
 SPIFFS = 100
@@ -62,7 +64,7 @@ def update_progress(progress):
     :return:
     """
     if PROGRESS:
-        barLength = 60  # Modify this to change the length of the progress bar
+        bar_length = 60  # Modify this to change the length of the progress bar
         status = ""
         if isinstance(progress, int):
             progress = float(progress)
@@ -75,8 +77,8 @@ def update_progress(progress):
         if progress >= 1:
             progress = 1
             status = "Done...\r\n"
-        block = int(round(barLength * progress))
-        text = "\rUploading: [{0}] {1}% {2}".format("=" * block + " " * (barLength - block),
+        block = int(round(bar_length * progress))
+        text = "\rUploading: [{0}] {1}% {2}".format("=" * block + " " * (bar_length - block),
                                                     int(progress * 100), status)
         sys.stderr.write(text)
         sys.stderr.flush()
@@ -93,14 +95,14 @@ def serve(remote_host, local_addr, remote_port, local_port, password, filename,
     try:
         sock.bind(server_address)
         sock.listen(1)
-    except Exception:
+    except Exception:  # pylint: disable=broad-except
         _LOGGER.error("Listen Failed")
         return 1
 
     content_size = os.path.getsize(filename)
-    f = open(filename, 'rb')
-    file_md5 = hashlib.md5(f.read()).hexdigest()
-    f.close()
+    f_handle = open(filename, 'rb')
+    file_md5 = hashlib.md5(f_handle.read()).hexdigest()
+    f_handle.close()
     _LOGGER.info('Upload size: %d', content_size)
     message = '%d %d %d %s\n' % (command, local_port, content_size, file_md5)
 
@@ -116,7 +118,7 @@ def serve(remote_host, local_addr, remote_port, local_port, password, filename,
         sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         try:
             sock2.sendto(message.encode(), remote_address)
-        except Exception:
+        except Exception:  # pylint: disable=broad-except
             _LOGGER.error('Failed')
             sock2.close()
             _LOGGER.error('Host %s Not Found', remote_host)
@@ -125,7 +127,7 @@ def serve(remote_host, local_addr, remote_port, local_port, password, filename,
         try:
             data = sock2.recv(37).decode()
             break
-        except Exception:
+        except Exception:  # pylint: disable=broad-except
             sys.stderr.write('.')
             sys.stderr.flush()
             sock2.close()
@@ -148,7 +150,7 @@ def serve(remote_host, local_addr, remote_port, local_port, password, filename,
             sock2.settimeout(10)
             try:
                 data = sock2.recv(32).decode()
-            except Exception:
+            except Exception:  # pylint: disable=broad-except
                 _LOGGER.error('FAIL: No Answer to our Authentication')
                 sock2.close()
                 return 1
@@ -166,35 +168,36 @@ def serve(remote_host, local_addr, remote_port, local_port, password, filename,
     _LOGGER.info('Waiting for device...')
     try:
         sock.settimeout(10)
-        connection, client_address = sock.accept()
+        connection, _ = sock.accept()
         sock.settimeout(None)
         connection.settimeout(None)
-    except Exception:
+    except Exception:  # pylint: disable=broad-except
         _LOGGER.error('No response from device')
         sock.close()
         return 1
 
     try:
-        f = open(filename, "rb")
+        f_handle = open(filename, "rb")
         if PROGRESS:
             update_progress(0)
         else:
             _LOGGER.info('Uploading...')
         offset = 0
         while True:
-            chunk = f.read(1024)
-            if not chunk: break
+            chunk = f_handle.read(1024)
+            if not chunk:
+                break
             offset += len(chunk)
             update_progress(offset / float(content_size))
             connection.settimeout(10)
             try:
                 connection.sendall(chunk)
                 connection.recv(10)
-            except Exception:
+            except Exception:  # pylint: disable=broad-except
                 sys.stderr.write('\n')
                 _LOGGER.error('Error Uploading')
                 connection.close()
-                f.close()
+                f_handle.close()
                 sock.close()
                 return 1
 
@@ -207,26 +210,26 @@ def serve(remote_host, local_addr, remote_port, local_port, password, filename,
                     break
             _LOGGER.info('Result: OK')
             connection.close()
-            f.close()
+            f_handle.close()
             sock.close()
             if data != "OK":
                 _LOGGER.error('%s', data)
                 return 1
-        except Exception:
+        except Exception:  # pylint: disable=broad-except
             _LOGGER.error('No Result!')
             connection.close()
-            f.close()
+            f_handle.close()
             sock.close()
             return 1
 
     finally:
         connection.close()
-        f.close()
+        f_handle.close()
 
     return 0
 
 
-def parser(unparsed_args):
+def parse_args(unparsed_args):
     parser = optparse.OptionParser(
         usage="%prog [options]",
         description="Transmit image over the air to the esp8266 module with OTA support."
@@ -234,82 +237,91 @@ def parser(unparsed_args):
 
     # destination ip and port
     group = optparse.OptionGroup(parser, "Destination")
-    group.add_option("-i", "--ip",
-                     dest="esp_ip",
-                     action="store",
-                     help="ESP8266 IP Address.",
-                     default=False
-                     )
-    group.add_option("-I", "--host_ip",
-                     dest="host_ip",
-                     action="store",
-                     help="Host IP Address.",
-                     default="0.0.0.0"
-                     )
-    group.add_option("-p", "--port",
-                     dest="esp_port",
-                     type="int",
-                     help="ESP8266 ota Port. Default 8266",
-                     default=8266
-                     )
-    group.add_option("-P", "--host_port",
-                     dest="host_port",
-                     type="int",
-                     help="Host server ota Port. Default random 10000-60000",
-                     default=random.randint(10000, 60000)
-                     )
+    group.add_option(
+        "-i", "--ip",
+        dest="esp_ip",
+        action="store",
+        help="ESP8266 IP Address.",
+        default=False
+    )
+    group.add_option(
+        "-I", "--host_ip",
+        dest="host_ip",
+        action="store",
+        help="Host IP Address.",
+        default="0.0.0.0"
+    )
+    group.add_option(
+        "-p", "--port",
+        dest="esp_port",
+        type="int",
+        help="ESP8266 ota Port. Default 8266",
+        default=8266
+    )
+    group.add_option(
+        "-P", "--host_port",
+        dest="host_port",
+        type="int",
+        help="Host server ota Port. Default random 10000-60000",
+        default=random.randint(10000, 60000)
+    )
     parser.add_option_group(group)
 
     # auth
     group = optparse.OptionGroup(parser, "Authentication")
-    group.add_option("-a", "--auth",
-                     dest="auth",
-                     help="Set authentication password.",
-                     action="store",
-                     default=""
-                     )
+    group.add_option(
+        "-a", "--auth",
+        dest="auth",
+        help="Set authentication password.",
+        action="store",
+        default=""
+    )
     parser.add_option_group(group)
 
     # image
     group = optparse.OptionGroup(parser, "Image")
-    group.add_option("-f", "--file",
-                     dest="image",
-                     help="Image file.",
-                     metavar="FILE",
-                     default=None
-                     )
-    group.add_option("-s", "--spiffs",
-                     dest="spiffs",
-                     action="store_true",
-                     help="Use this option to transmit a SPIFFS image and do not flash the "
-                          "module.",
-                     default=False
-                     )
+    group.add_option(
+        "-f", "--file",
+        dest="image",
+        help="Image file.",
+        metavar="FILE",
+        default=None
+    )
+    group.add_option(
+        "-s", "--spiffs",
+        dest="spiffs",
+        action="store_true",
+        help="Use this option to transmit a SPIFFS image and do not flash the "
+             "module.",
+        default=False
+    )
     parser.add_option_group(group)
 
     # output group
     group = optparse.OptionGroup(parser, "Output")
-    group.add_option("-d", "--debug",
-                     dest="debug",
-                     help="Show debug output. And override loglevel with debug.",
-                     action="store_true",
-                     default=False
-                     )
-    group.add_option("-r", "--progress",
-                     dest="progress",
-                     help="Show progress output. Does not work for ArduinoIDE",
-                     action="store_true",
-                     default=False
-                     )
+    group.add_option(
+        "-d", "--debug",
+        dest="debug",
+        help="Show debug output. And override loglevel with debug.",
+        action="store_true",
+        default=False
+    )
+    group.add_option(
+        "-r", "--progress",
+        dest="progress",
+        help="Show progress output. Does not work for ArduinoIDE",
+        action="store_true",
+        default=False
+    )
     parser.add_option_group(group)
 
-    (options, args) = parser.parse_args(unparsed_args)
+    options, _ = parser.parse_args(unparsed_args)
 
     return options
 
 
 def main(args):
-    options = parser(args)
+    options = parse_args(args)
     _LOGGER.debug("Options: %s", str(options))
 
     # check options

esphomeyaml/espota2.py

@@ -0,0 +1,292 @@
+import hashlib
+import logging
+import random
+import socket
+import sys
+
+from esphomeyaml.core import ESPHomeYAMLError
+
+RESPONSE_OK = 0
+RESPONSE_REQUEST_AUTH = 1
+
+RESPONSE_HEADER_OK = 64
+RESPONSE_AUTH_OK = 65
+RESPONSE_UPDATE_PREPARE_OK = 66
+RESPONSE_BIN_MD5_OK = 67
+RESPONSE_RECEIVE_OK = 68
+RESPONSE_UPDATE_END_OK = 69
+
+RESPONSE_ERROR_MAGIC = 128
+RESPONSE_ERROR_UPDATE_PREPARE = 129
+RESPONSE_ERROR_AUTH_INVALID = 130
+RESPONSE_ERROR_WRITING_FLASH = 131
+RESPONSE_ERROR_UPDATE_END = 132
+RESPONSE_ERROR_INVALID_BOOTSTRAPPING = 133
+RESPONSE_ERROR_UNKNOWN = 255
+
+OTA_VERSION_1_0 = 1
+
+MAGIC_BYTES = [0x6C, 0x26, 0xF7, 0x5C, 0x45]
+
+_LOGGER = logging.getLogger(__name__)
+LAST_PROGRESS = -1
+
+
+def update_progress(progress):
+    global LAST_PROGRESS
+
+    bar_length = 60
+    status = ""
+    if progress >= 1:
+        progress = 1
+        status = "Done...\r\n"
+    new_progress = int(progress * 100)
+    if new_progress == LAST_PROGRESS:
+        return
+    LAST_PROGRESS = new_progress
+    block = int(round(bar_length * progress))
+    text = "\rUploading: [{0}] {1}% {2}".format("=" * block + " " * (bar_length - block),
+                                                new_progress, status)
+    sys.stderr.write(text)
+    sys.stderr.flush()
+
+
+class OTAError(ESPHomeYAMLError):
+    pass
+
+
+def recv_decode(sock, amount, decode=True):
+    data = sock.recv(amount)
+    if not decode:
+        return data
+    return [ord(x) for x in data]
+
+
+def receive_exactly(sock, amount, msg, expect, decode=True):
+    if decode:
+        data = []
+    else:
+        data = ''
+
+    try:
+        data += recv_decode(sock, 1, decode=decode)
+    except socket.error as err:
+        raise OTAError("Error receiving acknowledge {}: {}".format(msg, err))
+
+    try:
+        check_error(data, expect)
+    except OTAError as err:
+        sock.close()
+        raise OTAError("Error {}: {}".format(msg, err))
+
+    while len(data) < amount:
+        try:
+            data += recv_decode(sock, amount - len(data), decode=decode)
+        except socket.error as err:
+            raise OTAError("Error receiving {}: {}".format(msg, err))
+    return data
+
+
+def check_error(data, expect):
+    if not expect:
+        return
+    dat = data[0]
+    if dat == RESPONSE_ERROR_MAGIC:
+        raise OTAError("Error: Invalid magic byte")
+    if dat == RESPONSE_ERROR_UPDATE_PREPARE:
+        raise OTAError("Error: Couldn't prepare flash memory for update. Is the binary too big? "
+                       "Please try restarting the ESP.")
+    if dat == RESPONSE_ERROR_AUTH_INVALID:
+        raise OTAError("Error: Authentication invalid. Is the password correct?")
+    if dat == RESPONSE_ERROR_WRITING_FLASH:
+        raise OTAError("Error: Wring OTA data to flash memory failed. See USB logs for more "
+                       "information.")
+    if dat == RESPONSE_ERROR_UPDATE_END:
+        raise OTAError("Error: Finishing update failed. See the MQTT/USB logs for more "
+                       "information.")
+    if dat == RESPONSE_ERROR_INVALID_BOOTSTRAPPING:
+        raise OTAError("Error: Please press the reset button on the ESP. A manual reset is "
+                       "required on the first OTA-Update after flashing via USB.")
+    if dat == RESPONSE_ERROR_UNKNOWN:
+        raise OTAError("Unknown error from ESP")
+    if not isinstance(expect, (list, tuple)):
+        expect = [expect]
+    if dat not in expect:
+        raise OTAError("Unexpected response from ESP: 0x{:02X}".format(data[0]))
+
+
+def send_check(sock, data, msg):
+    try:
+        if isinstance(data, (list, tuple)):
+            data = ''.join([chr(x) for x in data])
+        elif isinstance(data, int):
+            data = chr(data)
+        sock.sendall(data)
+    except socket.error as err:
+        raise OTAError("Error sending {}: {}".format(msg, err))
+
+
+def perform_ota(sock, password, file_handle, filename):
+    file_md5 = hashlib.md5(file_handle.read()).hexdigest()
+    file_size = file_handle.tell()
+    _LOGGER.info('Uploading %s (%s bytes)', filename, file_size)
+    file_handle.seek(0)
+    _LOGGER.debug("MD5 of binary is %s", file_md5)
+
+    # Enable nodelay, we need it for phase 1
+    sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    send_check(sock, MAGIC_BYTES, 'magic bytes')
+
+    _, version = receive_exactly(sock, 2, 'version', RESPONSE_OK)
+    if version != OTA_VERSION_1_0:
+        raise OTAError("Unsupported OTA version {}".format(version))
+
+    # Features
+    send_check(sock, 0x00, 'features')
+    receive_exactly(sock, 1, 'features', RESPONSE_HEADER_OK)
+
+    auth, = receive_exactly(sock, 1, 'auth', [RESPONSE_REQUEST_AUTH, RESPONSE_AUTH_OK])
+    if auth == RESPONSE_REQUEST_AUTH:
+        if not password:
+            raise OTAError("ESP requests password, but no password given!")
+        nonce = receive_exactly(sock, 32, 'authentication nonce', [], decode=False)
+        _LOGGER.debug("Auth: Nonce is %s", nonce)
+        cnonce = hashlib.md5(str(random.random()).encode()).hexdigest()
+        _LOGGER.debug("Auth: CNonce is %s", cnonce)
+
+        send_check(sock, cnonce, 'auth cnonce')
+
+        result_md5 = hashlib.md5()
+        result_md5.update(password.encode())
+        result_md5.update(nonce.encode())
+        result_md5.update(cnonce.encode())
+        result = result_md5.hexdigest()
+        _LOGGER.debug("Auth: Result is %s", result)
+
+        send_check(sock, result, 'auth result')
+        receive_exactly(sock, 1, 'auth result', RESPONSE_AUTH_OK)
+    else:
+        if password:
+            raise OTAError("Password specified, but ESP doesn't accept password!")
+
+    file_size_encoded = [
+        (file_size >> 24) & 0xFF,
+        (file_size >> 16) & 0xFF,
+        (file_size >> 8) & 0xFF,
+        (file_size >> 0) & 0xFF,
+    ]
+    send_check(sock, file_size_encoded, 'binary size')
+    receive_exactly(sock, 1, 'binary size', RESPONSE_UPDATE_PREPARE_OK)
+
+    send_check(sock, file_md5, 'file checksum')
+    receive_exactly(sock, 1, 'file checksum', RESPONSE_BIN_MD5_OK)
+
+    # Disable nodelay for transfer
+    sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 0)
+    # Limit send buffer (usually around 100kB) in order to have progress bar
+    # show the actual progress
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 8192)
+
+    offset = 0
+    update_progress(0.0)
+    while True:
+        chunk = file_handle.read(1024)
+        if not chunk:
+            break
+        offset += len(chunk)
+
+        try:
+            sock.sendall(chunk)
+        except socket.error as err:
+            sys.stderr.write('\n')
+            raise OTAError("Error sending data: {}".format(err))
+
+        update_progress(offset / float(file_size))
+
+    # Enable nodelay for last checks
+    sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+
+    sys.stderr.write('\n')
+    _LOGGER.info("Waiting for result...")
+
+    receive_exactly(sock, 1, 'receive OK', RESPONSE_RECEIVE_OK)
+    receive_exactly(sock, 1, 'Update end', RESPONSE_UPDATE_END_OK)
+    send_check(sock, RESPONSE_OK, 'end acknowledgement')
+
+    _LOGGER.info("OTA successful")
+
+
+def is_ip_address(host):
+    parts = host.split('.')
+    if len(parts) != 4:
+        return False
+    try:
+        for p in parts:
+            int(p)
+        return True
+    except ValueError:
+        return False
+
+
+def resolve_ip_address(host):
+    if is_ip_address(host):
+        _LOGGER.info("Connecting to %s", host)
+        return host
+
+    _LOGGER.info("Resolving IP Address of %s", host)
+    hosts = [host]
+    if host.endswith('.local'):
+        hosts.append(host[:-6])
+
+    errors = []
+    for x in hosts:
+        try:
+            ip = socket.gethostbyname(x)
+            break
+        except socket.error as err:
+            errors.append(err)
+    else:
+        _LOGGER.error("Error resolving IP address of %s. Is it connected to WiFi?",
+                      host)
+
+        _LOGGER.error("(If this error persists, please set a static IP address: "
+                      "https://esphomelib.com/esphomeyaml/components/wifi.html#manual-ips)")
+        raise OTAError("Errors: {}".format(', '.join(str(x) for x in errors)))
+
+    _LOGGER.info(" -> %s", ip)
+    return ip
+
+
+def run_ota(remote_host, remote_port, password, filename):
+    ip = resolve_ip_address(remote_host)
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.settimeout(10.0)
+    try:
+        sock.connect((ip, remote_port))
+    except socket.error as err:
+        sock.close()
+        _LOGGER.error("Connecting to %s:%s failed: %s", remote_host, remote_port, err)
+        return 1
+
+    file_handle = open(filename, 'rb')
+    try:
+        perform_ota(sock, password, file_handle, filename)
+    except OTAError as err:
+        _LOGGER.error(str(err))
+        return 1
+    finally:
+        sock.close()
+        file_handle.close()
+
+    return 0
+
+
+def run_legacy_ota(verbose, host_port, remote_host, remote_port, password, filename):
+    from esphomeyaml import espota
+
+    espota_args = ['espota.py', '--debug', '--progress', '-i', remote_host,
+                   '-p', str(remote_port), '-f', filename,
+                   '-a', password, '-P', str(host_port)]
+    if verbose:
+        espota_args.append('-d')
+    return espota.main(espota_args)

esphomeyaml/helpers.py

@@ -1,19 +1,20 @@
 from __future__ import print_function
 
-import logging
-import re
 from collections import OrderedDict, deque
+import inspect
+import logging
+import os
 
+from esphomeyaml import core
 from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, \
     CONF_INVERTED, \
-    CONF_MODE, CONF_NUMBER, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_RETAIN, \
-    CONF_STATE_TOPIC, CONF_TOPIC
-from esphomeyaml.core import ESPHomeYAMLError, HexInt
+    CONF_MODE, CONF_NUMBER, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PCF8574, \
+    CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC, CONF_SETUP_PRIORITY
+from esphomeyaml.core import ESPHomeYAMLError, HexInt, Lambda, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds
 
 _LOGGER = logging.getLogger(__name__)
 
-SIMPLIFY = False
-
 
 def ensure_unique_string(preferred_string, current_strings):
     test_string = preferred_string
@@ -45,10 +46,21 @@ def indent(text, padding=u'  '):
 
 class Expression(object):
     def __init__(self):
-        pass
+        self.requires = []
+        self.required = False
 
     def __str__(self):
-        raise NotImplemented
+        raise NotImplementedError
+
+    def require(self):
+        self.required = True
+        for require in self.requires:
+            if require.required:
+                continue
+            require.require()
+
+    def has_side_effects(self):
+        return self.required
 
 
 class RawExpression(Expression):
@@ -57,18 +69,26 @@ class RawExpression(Expression):
         self.text = text
 
     def __str__(self):
-        return self.text
+        return str(self.text)
 
 
+# pylint: disable=redefined-builtin
 class AssignmentExpression(Expression):
-    def __init__(self, lhs, rhs, obj):
+    def __init__(self, type, modifier, name, rhs, obj):
         super(AssignmentExpression, self).__init__()
-        self.obj = obj
-        self.lhs = safe_exp(lhs)
+        self.type = type
+        self.modifier = modifier
+        self.name = name
         self.rhs = safe_exp(rhs)
+        self.requires.append(self.rhs)
+        self.obj = obj
 
     def __str__(self):
-        return u"{} = {}".format(self.lhs, self.rhs)
+        type_ = self.type
+        return u"{} {}{} = {}".format(type_, self.modifier, self.name, self.rhs)
+
+    def has_side_effects(self):
+        return self.rhs.has_side_effects()
 
 
 class ExpressionList(Expression):
@@ -78,20 +98,43 @@ class ExpressionList(Expression):
         args = list(args)
         while args and args[-1] is None:
             args.pop()
-        self.args = [safe_exp(x) for x in args]
+        self.args = []
+        for arg in args:
+            exp = safe_exp(arg)
+            self.requires.append(exp)
+            self.args.append(exp)
 
     def __str__(self):
         text = u", ".join(unicode(x) for x in self.args)
         return indent_all_but_first_and_last(text)
 
 
+class TemplateArguments(Expression):
+    def __init__(self, *args):
+        super(TemplateArguments, self).__init__()
+        self.args = ExpressionList(*args)
+        self.requires.append(self.args)
+
+    def __str__(self):
+        return u'<{}>'.format(self.args)
+
+
 class CallExpression(Expression):
     def __init__(self, base, *args):
         super(CallExpression, self).__init__()
         self.base = base
+        if args and isinstance(args[0], TemplateArguments):
+            self.template_args = args[0]
+            self.requires.append(self.template_args)
+            args = args[1:]
+        else:
+            self.template_args = None
         self.args = ExpressionList(*args)
+        self.requires.append(self.args)
 
     def __str__(self):
+        if self.template_args is not None:
+            return u'{}{}({})'.format(self.base, self.template_args, self.args)
         return u'{}({})'.format(self.base, self.args)
 
 
@@ -99,48 +142,128 @@ class StructInitializer(Expression):
     def __init__(self, base, *args):
         super(StructInitializer, self).__init__()
         self.base = base
+        if isinstance(base, Expression):
+            self.requires.append(base)
         if not isinstance(args, OrderedDict):
             args = OrderedDict(args)
         self.args = OrderedDict()
         for key, value in args.iteritems():
-            if value is not None:
-                self.args[key] = safe_exp(value)
+            if value is None:
+                continue
+            exp = safe_exp(value)
+            self.args[key] = exp
+            self.requires.append(exp)
 
     def __str__(self):
-        s = u'{}{{\n'.format(self.base)
+        cpp = u'{}{{\n'.format(self.base)
         for key, value in self.args.iteritems():
-            s += u'  .{} = {},\n'.format(key, value)
-        s += u'}'
-        return s
+            cpp += u'  .{} = {},\n'.format(key, value)
+        cpp += u'}'
+        return cpp
 
 
 class ArrayInitializer(Expression):
-    def __init__(self, *args):
+    def __init__(self, *args, **kwargs):
         super(ArrayInitializer, self).__init__()
-        self.args = [safe_exp(x) for x in args if x is not None]
+        self.multiline = kwargs.get('multiline', True)
+        self.args = []
+        for arg in args:
+            if arg is None:
+                continue
+            exp = safe_exp(arg)
+            self.args.append(exp)
+            self.requires.append(exp)
 
     def __str__(self):
         if not self.args:
             return u'{}'
-        s = u'{\n'
-        for arg in self.args:
-            s += u'  {},\n'.format(arg)
-        s += u'}'
-        return s
+        if self.multiline:
+            cpp = u'{\n'
+            for arg in self.args:
+                cpp += u'  {},\n'.format(arg)
+            cpp += u'}'
+        else:
+            cpp = u'{' + u', '.join(str(arg) for arg in self.args) + u'}'
+        return cpp
+
+
+# pylint: disable=invalid-name
+class ParameterExpression(Expression):
+    def __init__(self, type, id):
+        super(ParameterExpression, self).__init__()
+        self.type = type
+        self.id = id
+
+    def __str__(self):
+        return u"{} {}".format(self.type, self.id)
+
+
+class ParameterListExpression(Expression):
+    def __init__(self, *parameters):
+        super(ParameterListExpression, self).__init__()
+        self.parameters = []
+        for parameter in parameters:
+            if not isinstance(parameter, ParameterExpression):
+                parameter = ParameterExpression(*parameter)
+            self.parameters.append(parameter)
+            self.requires.append(parameter)
+
+    def __str__(self):
+        return u", ".join(unicode(x) for x in self.parameters)
+
+
+class LambdaExpression(Expression):
+    def __init__(self, parts, parameters, capture='=', return_type=None):
+        super(LambdaExpression, self).__init__()
+        self.parts = parts
+        if not isinstance(parameters, ParameterListExpression):
+            parameters = ParameterListExpression(*parameters)
+        self.parameters = parameters
+        self.requires.append(self.parameters)
+        self.capture = capture
+        self.return_type = return_type
+        if return_type is not None:
+            self.requires.append(return_type)
+        for i in range(1, len(parts), 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(unicode(part) for part in self.parts)
 
 
 class Literal(Expression):
-    def __init__(self):
-        super(Literal, self).__init__()
+    def __str__(self):
+        raise NotImplementedError
+
+
+# From https://stackoverflow.com/a/14945195/8924614
+def cpp_string_escape(string, encoding='utf-8'):
+    if isinstance(string, unicode):
+        string = string.encode(encoding)
+    result = ''
+    for character in string:
+        if not (32 <= ord(character) < 127) or character in ('\\', '"'):
+            result += '\\%03o' % ord(character)
+        else:
+            result += character
+    return '"' + result + '"'
 
 
 class StringLiteral(Literal):
-    def __init__(self, s):
+    def __init__(self, string):
         super(StringLiteral, self).__init__()
-        self.s = s
+        self.string = string
 
     def __str__(self):
-        return u'"{}"'.format(self.s)
+        return u'{}'.format(cpp_string_escape(self.string))
 
 
 class IntLiteral(Literal):
@@ -149,16 +272,22 @@ class IntLiteral(Literal):
         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 unicode(self.i)
 
 
 class BoolLiteral(Literal):
-    def __init__(self, b):
+    def __init__(self, binary):
         super(BoolLiteral, self).__init__()
-        self.b = b
+        self.binary = binary
 
     def __str__(self):
-        return u"true" if self.b else u"false"
+        return u"true" if self.binary else u"false"
 
 
 class HexIntLiteral(Literal):
@@ -171,12 +300,12 @@ class HexIntLiteral(Literal):
 
 
 class FloatLiteral(Literal):
-    def __init__(self, f):
+    def __init__(self, value):
         super(FloatLiteral, self).__init__()
-        self.f = f
+        self.float_ = value
 
     def __str__(self):
-        return u"{:f}f".format(self.f)
+        return u"{:f}f".format(self.float_)
 
 
 def safe_exp(obj):
@@ -184,12 +313,20 @@ def safe_exp(obj):
         return obj
     elif isinstance(obj, bool):
         return BoolLiteral(obj)
-    elif isinstance(obj, str) or isinstance(obj, unicode):
+    elif isinstance(obj, (str, unicode)):
         return StringLiteral(obj)
+    elif isinstance(obj, HexInt):
+        return HexIntLiteral(obj)
     elif isinstance(obj, (int, long)):
         return IntLiteral(obj)
     elif isinstance(obj, float):
         return FloatLiteral(obj)
+    elif isinstance(obj, TimePeriodMicroseconds):
+        return IntLiteral(int(obj.total_microseconds))
+    elif isinstance(obj, TimePeriodMilliseconds):
+        return IntLiteral(int(obj.total_milliseconds))
+    elif isinstance(obj, TimePeriodSeconds):
+        return IntLiteral(int(obj.total_seconds))
     raise ValueError(u"Object is not an expression", obj)
 
 
@@ -198,7 +335,7 @@ class Statement(object):
         pass
 
     def __str__(self):
-        raise NotImplemented
+        raise NotImplementedError
 
 
 class RawStatement(Statement):
@@ -225,98 +362,293 @@ def statement(expression):
     return ExpressionStatement(expression)
 
 
-def variable(type, id, rhs):
-    lhs = RawExpression(u'{} {}'.format(type if not SIMPLIFY else u'auto', id))
+def register_variable(id, obj):
+    _LOGGER.debug("Registered variable %s of type %s", id.id, id.type)
+    _VARIABLES[id] = obj
+
+
+# pylint: disable=redefined-builtin, invalid-name
+def variable(id, rhs, type=None):
     rhs = safe_exp(rhs)
     obj = MockObj(id, u'.')
-    add(AssignmentExpression(lhs, rhs, obj))
-    _VARIABLES[id] = obj, type
+    id.type = type or id.type
+    assignment = AssignmentExpression(id.type, '', id, rhs, obj)
+    add(assignment)
+    register_variable(id, obj)
+    obj.requires.append(assignment)
     return obj
 
 
-def Pvariable(type, id, rhs):
-    lhs = RawExpression(u'{} *{}'.format(type if not SIMPLIFY else u'auto', id))
+def Pvariable(id, rhs, has_side_effects=True, type=None):
     rhs = safe_exp(rhs)
-    obj = MockObj(id, u'->')
-    add(AssignmentExpression(lhs, rhs, obj))
-    _VARIABLES[id] = obj, type
+    if not has_side_effects and hasattr(rhs, '_has_side_effects'):
+        # pylint: disable=attribute-defined-outside-init, protected-access
+        rhs._has_side_effects = False
+    obj = MockObj(id, u'->', has_side_effects=has_side_effects)
+    id.type = type or id.type
+    assignment = AssignmentExpression(id.type, '*', id, rhs, obj)
+    add(assignment)
+    register_variable(id, obj)
+    obj.requires.append(assignment)
     return obj
 
 
-_QUEUE = deque()
+_TASKS = deque()
 _VARIABLES = {}
 _EXPRESSIONS = []
 
 
-def get_variable(id, type=None):
-    result = None
-    while _QUEUE:
-        if id is not None:
-            if id in _VARIABLES:
-                result = _VARIABLES[id][0]
-                break
-        elif type is not None:
-            result = next((x[0] for x in _VARIABLES.itervalues() if x[1] == type), None)
-            if result is not None:
-                break
-        func, config = _QUEUE.popleft()
-        func(config)
-    if id is None and type is None:
-        return None
-    if result is None:
-        if id is not None:
-            result = _VARIABLES[id][0]
-        elif type is not None:
-            result = next((x[0] for x in _VARIABLES.itervalues() if x[1] == type), None)
-
-        if result is None:
-            raise ESPHomeYAMLError(u"Couldn't find ID '{}' with type {}".format(id, type))
-    result.usages += 1
-    return result
+def get_variable(id):
+    while True:
+        if id in _VARIABLES:
+            yield _VARIABLES[id]
+            return
+        _LOGGER.debug("Waiting for variable %s", id)
+        yield None
 
 
-def add_task(func, config):
-    _QUEUE.append((func, config))
+def get_variable_with_full_id(id):
+    while True:
+        for k, v in _VARIABLES.iteritems():
+            if k == id:
+                yield (k, v)
+                return
+        _LOGGER.debug("Waiting for variable %s", id)
+        yield None, None
 
 
-def add(expression):
+def process_lambda(value, parameters, capture='=', return_type=None):
+    from esphomeyaml.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 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, input_type, output_type):
+    if isinstance(value, Lambda):
+        lambda_ = None
+        for lambda_ in process_lambda(value, [(input_type, 'x')], return_type=output_type):
+            yield None
+        yield lambda_
+    else:
+        yield value
+
+
+def add_job(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_()
+    _TASKS.append((gen, domain))
+    return gen
+
+
+def flush_tasks():
+    i = 0
+    while _TASKS:
+        i += 1
+        if i > 1000000:
+            raise ESPHomeYAMLError("Circular dependency detected!")
+
+        task, domain = _TASKS.popleft()
+        _LOGGER.debug("Executing task for domain=%s", domain)
+        try:
+            task.next()
+            _TASKS.append((task, domain))
+        except StopIteration:
+            _LOGGER.debug(" -> %s finished", domain)
+
+
+def add(expression, require=True):
+    if require and isinstance(expression, Expression):
+        expression.require()
     _EXPRESSIONS.append(expression)
+    _LOGGER.debug("Adding: %s", statement(expression))
     return expression
 
 
 class MockObj(Expression):
-    def __init__(self, base, op=u'.', parent=None):
+    def __init__(self, base, op=u'.', has_side_effects=True):
         self.base = base
         self.op = op
-        self.usages = 0
-        self.parent = parent
+        self._has_side_effects = has_side_effects
         super(MockObj, self).__init__()
 
     def __getattr__(self, attr):
+        if attr == u'_':
+            obj = MockObj(u'{}{}'.format(self.base, self.op))
+            obj.requires.append(self)
+            return obj
+        if attr == u'new':
+            obj = MockObj(u'new {}'.format(self.base), u'->')
+            obj.requires.append(self)
+            return obj
         next_op = u'.'
-        if attr.startswith(u'P'):
+        if attr.startswith(u'P') and self.op not in ['::', '']:
             attr = attr[1:]
             next_op = u'->'
-        op = self.op
-        return MockObj(u'{}{}{}'.format(self.base, op, attr), next_op, self)
+        if attr.startswith(u'_'):
+            attr = attr[1:]
+        obj = MockObj(u'{}{}{}'.format(self.base, self.op, attr), next_op)
+        obj.requires.append(self)
+        return obj
 
     def __call__(self, *args, **kwargs):
-        self.usages += 1
-        it = self.parent
-        while it is not None:
-            it.usages += 1
-            it = it.parent
-        return CallExpression(self.base, *args)
+        call = CallExpression(self.base, *args)
+        obj = MockObj(call, self.op)
+        obj.requires.append(self)
+        obj.requires.append(call)
+        return obj
 
     def __str__(self):
-        return self.base
+        return unicode(self.base)
+
+    def require(self):
+        self.required = True
+        for require in self.requires:
+            if require.required:
+                continue
+            require.require()
+
+    def template(self, args):
+        if not isinstance(args, TemplateArguments):
+            args = TemplateArguments(args)
+        obj = MockObj(u'{}{}'.format(self.base, args))
+        obj.requires.append(self)
+        obj.requires.append(args)
+        return obj
+
+    def namespace(self, name):
+        obj = MockObj(u'{}{}{}'.format(self.base, self.op, name), u'::')
+        obj.requires.append(self)
+        return obj
+
+    def class_(self, name, *parents):
+        obj = MockObjClass(u'{}::{}'.format(self.base, name), u'.', parents=parents)
+        obj.requires.append(self)
+        return obj
+
+    def struct(self, name):
+        return self.class_(name)
+
+    def enum(self, name, is_class=False):
+        if is_class:
+            return self.namespace(name)
+
+        return self
+
+    def operator(self, name):
+        if name == 'ref':
+            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):
+        return self._has_side_effects
+
+    def __getitem__(self, item):
+        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
 
 
-App = MockObj(u'App')
+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
 
-GPIOPin = MockObj(u'GPIOPin')
-GPIOOutputPin = MockObj(u'GPIOOutputPin')
-GPIOInputPin = MockObj(u'GPIOInputPin')
+    def inherits_from(self, other):
+        if self == other:
+            return True
+        for parent in self._parents:
+            if parent == other:
+                return True
+        return False
+
+    def template(self, args):
+        if not isinstance(args, TemplateArguments):
+            args = TemplateArguments(args)
+        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
+
+
+global_ns = MockObj('', '')
+float_ = global_ns.namespace('float')
+bool_ = global_ns.namespace('bool')
+std_ns = global_ns.namespace('std')
+std_string = std_ns.string
+uint8 = global_ns.namespace('uint8_t')
+uint16 = global_ns.namespace('uint16_t')
+uint32 = global_ns.namespace('uint32_t')
+int32 = global_ns.namespace('int32_t')
+const_char_p = global_ns.namespace('const char *')
+NAN = global_ns.namespace('NAN')
+esphomelib_ns = global_ns  # using namespace esphomelib;
+NoArg = esphomelib_ns.NoArg
+App = esphomelib_ns.App
+io_ns = esphomelib_ns.namespace('io')
+Nameable = esphomelib_ns.class_('Nameable')
+Trigger = esphomelib_ns.class_('Trigger')
+Action = esphomelib_ns.class_('Action')
+Component = esphomelib_ns.class_('Component')
+PollingComponent = esphomelib_ns.class_('PollingComponent', Component)
+Application = esphomelib_ns.class_('Application')
+optional = esphomelib_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 = esphomelib_ns.class_('Controller')
+StoringController = esphomelib_ns.class_('StoringController', Controller)
+
+GPIOPin = esphomelib_ns.class_('GPIOPin')
+GPIOOutputPin = esphomelib_ns.class_('GPIOOutputPin', GPIOPin)
+GPIOInputPin = esphomelib_ns.class_('GPIOInputPin', GPIOPin)
 
 
 def get_gpio_pin_number(conf):
@@ -325,25 +657,45 @@ def get_gpio_pin_number(conf):
     return conf[CONF_NUMBER]
 
 
-def exp_gpio_pin_(obj, conf, default_mode):
-    if isinstance(conf, int):
-        return conf
-    if conf.get(CONF_INVERTED) is None:
-        return obj(conf[CONF_NUMBER], conf.get(CONF_MODE))
-    return obj(conf[CONF_NUMBER], RawExpression(conf.get(CONF_MODE, default_mode)),
-               conf[CONF_INVERTED])
+def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
+    if conf is None:
+        return
+    number = conf[CONF_NUMBER]
+    inverted = conf.get(CONF_INVERTED)
+    if CONF_PCF8574 in conf:
+        hub = None
+        for hub in get_variable(conf[CONF_PCF8574]):
+            yield None
+        if default_mode == u'INPUT':
+            mode = conf.get(CONF_MODE, u'INPUT')
+            yield hub.make_input_pin(number,
+                                     RawExpression('PCF8574_' + mode),
+                                     inverted)
+            return
+        elif default_mode == u'OUTPUT':
+            yield hub.make_output_pin(number, inverted)
+            return
+        else:
+            raise ESPHomeYAMLError(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 exp_gpio_pin(conf):
-    return GPIOPin(conf[CONF_NUMBER], conf[CONF_MODE], conf.get(CONF_INVERTED))
+def gpio_output_pin_expression(conf):
+    exp = None
+    for exp in generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT'):
+        yield None
+    yield exp
 
 
-def exp_gpio_output_pin(conf):
-    return exp_gpio_pin_(GPIOOutputPin, conf, u'OUTPUT')
-
-
-def exp_gpio_input_pin(conf):
-    return exp_gpio_pin_(GPIOInputPin, conf, u'INPUT')
+def gpio_input_pin_expression(conf):
+    exp = None
+    for exp in generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT'):
+        yield None
+    yield exp
 
 
 def setup_mqtt_component(obj, config):
@@ -357,44 +709,25 @@ def setup_mqtt_component(obj, config):
         add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
     if CONF_AVAILABILITY in config:
         availability = config[CONF_AVAILABILITY]
-        exp = StructInitializer(
-            u'mqtt::Availability',
-            (u'topic', availability[CONF_TOPIC]),
-            (u'payload_available', availability[CONF_PAYLOAD_AVAILABLE]),
-            (u'payload_not_available', availability[CONF_PAYLOAD_NOT_AVAILABLE]),
-        )
-        add(obj.set_availability(exp))
+        if not availability:
+            add(obj.disable_availability())
+        else:
+            add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
+                                     availability[CONF_PAYLOAD_NOT_AVAILABLE]))
 
 
-def exp_empty_optional(type):
-    return RawExpression(u'Optional<{}>()'.format(type))
+def setup_component(obj, config):
+    if CONF_SETUP_PRIORITY in config:
+        add(obj.set_setup_priority(config[CONF_SETUP_PRIORITY]))
 
 
-def exp_optional(type, value):
-    if value is None:
-        return exp_empty_optional(type)
-    return value
-
-
-# shlex's quote for Python 2.7
-_find_unsafe = re.compile(r'[^\w@%+=:,./-]').search
-
-
-def quote(s):
-    """Return a shell-escaped version of the string *s*."""
-    if not s:
-        return u"''"
-    if _find_unsafe(s) is None:
-        return s
-
-    # use single quotes, and put single quotes into double quotes
-    # the string $'b is then quoted as '$'"'"'b'
-    return u"'" + s.replace(u"'", u"'\"'\"'") + u"'"
-
-
-def color(the_color, message = '', reset=None):
+def color(the_color, message='', reset=None):
     """Color helper."""
     from colorlog.escape_codes import escape_codes, parse_colors
     if not message:
         return parse_colors(the_color)
     return parse_colors(the_color) + message + escape_codes[reset or 'reset']
+
+
+def relative_path(path):
+    return os.path.join(os.path.dirname(core.CONFIG_PATH), os.path.expanduser(path))

esphomeyaml/mqtt.py

@@ -1,19 +1,26 @@
 from __future__ import print_function
 
+import hashlib
 import logging
+import ssl
+import sys
 from datetime import datetime
 
 import paho.mqtt.client as mqtt
 
-from esphomeyaml.const import CONF_BROKER, CONF_DISCOVERY_PREFIX, CONF_ESPHOMEYAML, CONF_LOGGER, \
-    CONF_LOG_TOPIC, CONF_MQTT, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_TOPIC_PREFIX, \
-    CONF_USERNAME
+from esphomeyaml import core
+from esphomeyaml.const import CONF_BROKER, CONF_DISCOVERY_PREFIX, CONF_ESPHOMEYAML, \
+    CONF_LOG_TOPIC, \
+    CONF_MQTT, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_TOPIC_PREFIX, \
+    CONF_USERNAME, CONF_TOPIC, CONF_SSL_FINGERPRINTS
+from esphomeyaml.helpers import color
+from esphomeyaml.util import safe_print
 
 _LOGGER = logging.getLogger(__name__)
 
 
 def initialize(config, subscriptions, on_message, username, password, client_id):
-    def on_connect(client, userdata, flags, rc):
+    def on_connect(client, userdata, flags, return_code):
         for topic in subscriptions:
             client.subscribe(topic)
 
@@ -26,6 +33,14 @@ def initialize(config, subscriptions, on_message, username, password, client_id)
                                    config[CONF_MQTT][CONF_PASSWORD])
     elif username:
         client.username_pw_set(username, password)
+
+    if config[CONF_MQTT].get(CONF_SSL_FINGERPRINTS):
+        if sys.version_info >= (2, 7, 13):
+            tls_version = ssl.PROTOCOL_TLS  # pylint: disable=no-member
+        else:
+            tls_version = ssl.PROTOCOL_SSLv23
+        client.tls_set(ca_certs=None, certfile=None, keyfile=None, cert_reqs=ssl.CERT_REQUIRED,
+                       tls_version=tls_version, ciphers=None)
     client.connect(config[CONF_MQTT][CONF_BROKER], config[CONF_MQTT][CONF_PORT])
 
     try:
@@ -35,20 +50,28 @@ def initialize(config, subscriptions, on_message, username, password, client_id)
     return 0
 
 
-def show_logs(config, topic=None, username=None, password=None, client_id=None):
+def show_logs(config, topic=None, username=None, password=None, client_id=None, escape=False):
     if topic is not None:
         pass  # already have topic
-    elif CONF_LOG_TOPIC in config.get(CONF_LOGGER, {}):
-        topic = config[CONF_LOGGER][CONF_LOG_TOPIC]
-    elif CONF_TOPIC_PREFIX in config[CONF_MQTT]:
-        topic = config[CONF_MQTT][CONF_TOPIC_PREFIX] + u'/debug'
+    elif CONF_MQTT in config:
+        conf = config[CONF_MQTT]
+        if CONF_LOG_TOPIC in conf:
+            topic = config[CONF_MQTT][CONF_LOG_TOPIC][CONF_TOPIC]
+        elif CONF_TOPIC_PREFIX in config[CONF_MQTT]:
+            topic = config[CONF_MQTT][CONF_TOPIC_PREFIX] + u'/debug'
+        else:
+            topic = config[CONF_ESPHOMEYAML][CONF_NAME] + u'/debug'
     else:
-        topic = config[CONF_ESPHOMEYAML][CONF_NAME] + u'/debug'
+        _LOGGER.error(u"MQTT isn't setup, can't start MQTT logs")
+        return 1
     _LOGGER.info(u"Starting log output from %s", topic)
 
     def on_message(client, userdata, msg):
-        t = datetime.now().time().strftime(u'[%H:%M:%S] ')
-        print(t + msg.payload)
+        time = datetime.now().time().strftime(u'[%H:%M:%S]')
+        message = time + msg.payload
+        if escape:
+            message = message.replace('\033', '\\033')
+        safe_print(message)
 
     return initialize(config, [topic], on_message, username, password, client_id)
 
@@ -58,12 +81,37 @@ def clear_topic(config, topic, username=None, password=None, client_id=None):
         discovery_prefix = config[CONF_MQTT].get(CONF_DISCOVERY_PREFIX, u'homeassistant')
         name = config[CONF_ESPHOMEYAML][CONF_NAME]
         topic = u'{}/+/{}/#'.format(discovery_prefix, name)
-    _LOGGER.info(u"Clearing messages from {}".format(topic))
+    _LOGGER.info(u"Clearing messages from '%s'", topic)
+    _LOGGER.info(u"Please close this window when no more messages appear and the "
+                 u"MQTT topic has been cleared of retained messages.")
 
     def on_message(client, userdata, msg):
-        if not msg.payload:
+        if not msg.payload or not msg.retain:
+            return
+        try:
+            print(u"Clearing topic {}".format(msg.topic))
+        except UnicodeDecodeError:
+            print(u"Skipping non-UTF-8 topic (prohibited by MQTT standard)")
             return
-        print(u"Clearing topic {}".format(msg.topic))
         client.publish(msg.topic, None, retain=True)
 
     return initialize(config, [topic], on_message, username, password, client_id)
+
+
+# From marvinroger/async-mqtt-client -> scripts/get-fingerprint/get-fingerprint.py
+def get_fingerprint(config):
+    addr = config[CONF_MQTT][CONF_BROKER], config[CONF_MQTT][CONF_PORT]
+    _LOGGER.info("Getting fingerprint from %s:%s", addr[0], addr[1])
+    try:
+        cert_pem = ssl.get_server_certificate(addr)
+    except IOError as err:
+        _LOGGER.error("Unable to connect to server: %s", err)
+        return 1
+    cert_der = ssl.PEM_cert_to_DER_cert(cert_pem)
+
+    sha1 = hashlib.sha1(cert_der).hexdigest()
+
+    safe_print(u"SHA1 Fingerprint: " + color('cyan', sha1))
+    safe_print(u"Copy the string above into mqtt.ssl_fingerprints section of {}"
+               u"".format(core.CONFIG_PATH))
+    return 0

esphomeyaml/pins.py

@@ -2,68 +2,174 @@ import logging
 
 import voluptuous as vol
 
+from esphomeyaml import core
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, CONF_NUMBER, CONF_MODE, \
-    CONF_INVERTED
+from esphomeyaml.const import CONF_INVERTED, CONF_MODE, CONF_NUMBER, CONF_PCF8574, \
+    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
+from esphomeyaml.helpers import Component, esphomelib_ns, io_ns
 
 _LOGGER = logging.getLogger(__name__)
 
-ESP8266_PINS = {
-    'A0': 17, 'SS': 15, 'MOSI': 13, 'MISO': 12, 'SCK': 14,
-}
-ESP8266_NODEMCU_PINS = dict(ESP8266_PINS, **{
-    'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 2, 'D5': 14, 'D6': 12, 'D7': 13, 'D8': 15, 'D9': 3,
-    'D10': 1, 'LED': 16, 'SDA': 4, 'SCL': 5,
-})
-ESP8266_D1_PINS = dict(ESP8266_PINS, **{
-    'D0': 3, 'D1': 1, 'D2': 16, 'D3': 5, 'D4': 4, 'D5': 14, 'D6': 12, 'D7': 13, 'D8': 0, 'D9': 2,
-    'D10': 15, 'D11': 13, 'D12': 14, 'D13': 14, 'D14': 4, 'D15': 5, 'LED': 2, 'SDA': 4, 'SCL': 5,
-})
-ESP8266_D1_MINI_PINS = dict(ESP8266_PINS, **{
-    'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 0, 'D5': 14, 'D6': 12, 'D7': 13, 'D8': 15, 'RX': 3,
-    'TX': 1, 'LED': 2, 'SDA': 4, 'SCL': 5,
-})
-ESP8266_THING_PINS = dict(ESP8266_PINS, **{
-    'LED': 5, 'SDA': 2, 'SCL': 14,
-})
-ESP8266_ADAFRUIT_PINS = dict(ESP8266_PINS, **{
-    'LED': 0, 'SDA': 4, 'SCL': 5,
-})
-ESP8266_ESPDUINO_PINS = dict(ESP8266_PINS, **{
-    'LED': 16, 'SDA': 4, 'SCL': 5,
-})
-ESP8266_BOARD_TO_PINS = {
-    'huzzah': ESP8266_ADAFRUIT_PINS,
-    'espduino': ESP8266_ESPDUINO_PINS,
-    'nodemcu': ESP8266_NODEMCU_PINS, 'nodemcuv2': ESP8266_NODEMCU_PINS,
-    'thing': ESP8266_THING_PINS, 'thingdev': ESP8266_THING_PINS,
-    'd1': ESP8266_D1_PINS,
-    'd1_mini': ESP8266_D1_MINI_PINS, 'd1_mini_lite': ESP8266_D1_MINI_PINS,
-    'd1_mini_pro': ESP8266_D1_MINI_PINS
+ESP8266_BASE_PINS = {
+    'A0': 17, 'SS': 15, 'MOSI': 13, 'MISO': 12, 'SCK': 14, 'SDA': 4, 'SCL': 5, 'RX': 3, 'TX': 1
 }
 
-ESP32_PINS = {
+ESP8266_BOARD_PINS = {
+    'd1': {'D0': 3, 'D1': 1, 'D2': 16, 'D3': 5, 'D4': 4, 'D5': 14, 'D6': 12, 'D7': 13, 'D8': 0,
+           'D9': 2, 'D10': 15, 'D11': 13, 'D12': 14, 'D13': 14, 'D14': 4, 'D15': 5, 'LED': 2},
+    'd1_mini': {'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 2, 'D5': 14, 'D6': 12, 'D7': 13,
+                'D8': 15, 'LED': 2},
+    'd1_mini_lite': 'd1_mini',
+    'd1_mini_pro': 'd1_mini',
+    'esp01': {},
+    'esp01_1m': {},
+    'esp07': {},
+    'esp12e': {},
+    'esp210': {},
+    'esp8285': {},
+    'esp_wroom_02': {},
+    'espduino': {'LED': 16},
+    'espectro': {'LED': 15, 'BUTTON': 2},
+    'espino': {'LED': 2, 'LED_RED': 2, 'LED_GREEN': 4, 'LED_BLUE': 5, 'BUTTON': 0},
+    'espinotee': {'LED': 16},
+    'espresso_lite_v1': {'LED': 16},
+    'espresso_lite_v2': {'LED': 2},
+    'gen4iod': {},
+    'heltec_wifi_kit_8': 'd1_mini',
+    'huzzah': {'LED': 0},
+    'modwifi': {},
+    'nodemcu': {'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 2, 'D5': 14, 'D6': 12, 'D7': 13,
+                'D8': 15, 'D9': 3, 'D10': 1, 'LED': 16},
+    'nodemcuv2': 'nodemcu',
+    'oak': {'P0': 2, 'P1': 5, 'P2': 0, 'P3': 3, 'P4': 1, 'P5': 4, 'P6': 15, 'P7': 13, 'P8': 12,
+            'P9': 14, 'P10': 16, 'P11': 17, 'LED': 5},
+    'phoenix_v1': {'LED': 16},
+    'phoenix_v2': {'LED': 2},
+    'sparkfunBlynk': 'thing',
+    'thing': {'LED': 5, 'SDA': 2, 'SCL': 14},
+    'thingdev': 'thing',
+    'wifi_slot': {'LED': 2},
+    'wifiduino': {'D0': 3, 'D1': 1, 'D2': 2, 'D3': 0, 'D4': 4, 'D5': 5, 'D6': 16, 'D7': 14,
+                  'D8': 12, 'D9': 13, 'D10': 15, 'D11': 13, 'D12': 12, 'D13': 14},
+    'wifinfo': {'LED': 12, 'D0': 16, 'D1': 5, 'D2': 4, 'D3': 0, 'D4': 2, 'D5': 14, 'D6': 12,
+                'D7': 13, 'D8': 15, 'D9': 3, 'D10': 1},
+    'wio_link': {'LED': 2, 'GROVE': 15},
+    'wio_node': 'nodemcu',
+    'xinabox_cw01': {'SDA': 2, 'SCL': 14, 'LED': 5, 'LED_RED': 12, 'LED_GREEN': 13}
+}
+
+ESP32_BASE_PINS = {
     'TX': 1, 'RX': 3, 'SDA': 21, 'SCL': 22, 'SS': 5, 'MOSI': 23, 'MISO': 19, 'SCK': 18, 'A0': 36,
     'A3': 39, 'A4': 32, 'A5': 33, 'A6': 34, 'A7': 35, 'A10': 4, 'A11': 0, 'A12': 2, 'A13': 15,
     'A14': 13, 'A15': 12, 'A16': 14, 'A17': 27, 'A18': 25, 'A19': 26, 'T0': 4, 'T1': 0, 'T2': 2,
-    'T3': 15, 'T4': 12, 'T5': 12, 'T6': 14, 'T7': 27, 'T8': 33, 'T9': 32, 'DAC1': 25, 'DAC2': 26,
+    'T3': 15, 'T4': 13, 'T5': 12, 'T6': 14, 'T7': 27, 'T8': 33, 'T9': 32, 'DAC1': 25, 'DAC2': 26,
     'SVP': 36, 'SVN': 39,
 }
-ESP32_NODEMCU_32S_PINS = dict(ESP32_PINS, **{
-    'LED': 2,
-})
-ESP32_LOLIN32_PINS = dict(ESP32_PINS, **{
-    'LED': 5
-})
-ESP32_BOARD_TO_PINS = {
-    'nodemcu-32s': ESP32_NODEMCU_32S_PINS,
-    'lolin32': ESP32_LOLIN32_PINS,
+
+ESP32_BOARD_PINS = {
+    'alksesp32': {'D0': 40, 'D1': 41, 'D2': 15, 'D3': 2, 'D4': 0, 'D5': 4, 'D6': 16, 'D7': 17,
+                  'D8': 5, 'D9': 18, 'D10': 19, 'D11': 21, 'D12': 22, 'D13': 23, 'A0': 32, 'A1': 33,
+                  'A2': 25, 'A3': 26, 'A4': 27, 'A5': 14, 'A6': 12, 'A7': 15, 'L_R': 22, 'L_G': 17,
+                  'L_Y': 23, 'L_B': 5, 'L_RGB_R': 4, 'L_RGB_G': 21, 'L_RGB_B': 16, 'SW1': 15,
+                  'SW2': 2, 'SW3': 0, 'POT1': 32, 'POT2': 33, 'PIEZO1': 19, 'PIEZO2': 18,
+                  'PHOTO': 25, 'DHT_PIN': 26, 'S1': 4, 'S2': 16, 'S3': 18, 'S4': 19, 'S5': 21,
+                  'SDA': 27, 'SCL': 14, 'SS': 19, 'MOSI': 21, 'MISO': 22, 'SCK': 23},
+    'esp-wrover-kit': {},
+    'esp32-evb': {'BUTTON': 34, 'SDA': 13, 'SCL': 16, 'SS': 17, 'MOSI': 2, 'MISO': 15, 'SCK': 14},
+    'esp32-gateway': {'LED': 33, 'BUTTON': 34, 'SCL': 16, 'SDA': 17},
+    'esp320': {'LED': 5, 'SDA': 2, 'SCL': 14, 'SS': 15, 'MOSI': 13, 'MISO': 12, 'SCK': 14},
+    'esp32dev': {},
+    'esp32doit-devkit-v1': {'LED': 2},
+    'esp32thing': {'LED': 5, 'BUTTON': 0, 'SS': 2},
+    'esp32vn-iot-uno': {},
+    'espea32': {'LED': 5, 'BUTTON': 0},
+    'espectro32': {'LED': 15, 'SD_SS': 33},
+    'espino32': {'LED': 16, 'BUTTON': 0},
+    'featheresp32': {'LED': 13, 'TX': 17, 'RX': 16, 'SDA': 23, 'SS': 2, 'MOSI': 18, 'SCK': 5,
+                     'A0': 26, 'A1': 25, 'A2': 34, 'A4': 36, 'A5': 4, 'A6': 14, 'A7': 32, 'A8': 15,
+                     'A9': 33, 'A10': 27, 'A11': 12, 'A12': 13, 'A13': 35},
+    'firebeetle32': {'LED': 2},
+    'heltec_wifi_kit_32': {'LED': 25, 'BUTTON': 0, 'A1': 37, 'A2': 38},
+    'heltec_wifi_lora_32': {'LED': 25, 'BUTTON': 0, 'SDA': 4, 'SCL': 15, 'SS': 18, 'MOSI': 27,
+                            'SCK': 5, 'A1': 37, 'A2': 38, 'T8': 32, 'T9': 33, 'DAC1': 26,
+                            'DAC2': 25, 'OLED_SCL': 15, 'OLED_SDA': 4, 'OLED_RST': 16,
+                            'LORA_SCK': 5, 'LORA_MOSI': 27, 'LORA_MISO': 19, 'LORA_CS': 18,
+                            'LORA_RST': 14, 'LORA_IRQ': 26},
+    'hornbill32dev': {'LED': 13, 'BUTTON': 0},
+    'hornbill32minima': {'SS': 2},
+    'intorobot': {'LED': 4, 'LED_RED': 27, 'LED_GREEN': 21, 'LED_BLUE': 22,
+                  'BUTTON': 0, 'SDA': 23, 'SCL': 19, 'MOSI': 16, 'MISO': 17, 'A1': 39, 'A2': 35,
+                  'A3': 25, 'A4': 26, 'A5': 14, 'A6': 12, 'A7': 15, 'A8': 13, 'A9': 2, 'D0': 19,
+                  'D1': 23, 'D2': 18, 'D3': 17, 'D4': 16, 'D5': 5, 'D6': 4, 'T0': 19, 'T1': 23,
+                  'T2': 18, 'T3': 17, 'T4': 16, 'T5': 5, 'T6': 4},
+    'lolin32': {'LED': 5},
+    'lolin_d32': {'LED': 5, 'VBAT': 35},
+    'lolin_d32_pro': {'LED': 5, 'VBAT': 35, 'TF_CS': 4, 'TS_CS': 12, 'TFT_CS': 14, 'TFT_LED': 32,
+                      'TFT_RST': 33, 'TFT_DC': 27},
+    'm5stack-core-esp32': {'TXD2': 17, 'RXD2': 16, 'G23': 23, 'G19': 19, 'G18': 18, 'G3': 3,
+                           'G16': 16, 'G21': 21, 'G2': 2, 'G12': 12, 'G15': 15, 'G35': 35,
+                           'G36': 36, 'G25': 25, 'G26': 26, 'G1': 1, 'G17': 17, 'G22': 22, 'G5': 5,
+                           'G13': 13, 'G0': 0, 'G34': 34, 'ADC1': 35, 'ADC2': 36},
+    'm5stack-fire': {'G23': 23, 'G19': 19, 'G18': 18, 'G3': 3, 'G16': 16, 'G21': 21, 'G2': 2,
+                     'G12': 12, 'G15': 15, 'G35': 35, 'G36': 36, 'G25': 25, 'G26': 26, 'G1': 1,
+                     'G17': 17, 'G22': 22, 'G5': 5, 'G13': 13, 'G0': 0, 'G34': 34, 'ADC1': 35,
+                     'ADC2': 36},
+    'mhetesp32devkit': {'LED': 2},
+    'mhetesp32minikit': {'LED': 2},
+    'microduino-core-esp32': {'SDA': 22, 'SCL': 21, 'SDA1': 12, 'SCL1': 13, 'A0': 12, 'A1': 13,
+                              'A2': 15, 'A3': 4, 'A6': 38, 'A7': 37, 'A8': 32, 'A9': 33, 'A10': 25,
+                              'A11': 26, 'A12': 27, 'A13': 14, 'D0': 3, 'D1': 1, 'D2': 16, 'D3': 17,
+                              'D4': 32, 'D5': 33, 'D6': 25, 'D7': 26, 'D8': 27, 'D9': 14, 'D10': 5,
+                              'D11': 23, 'D12': 19, 'D13': 18, 'D14': 12, 'D15': 13, 'D16': 15,
+                              'D17': 4, 'D18': 22, 'D19': 21, 'D20': 38, 'D21': 37},
+    'nano32': {'LED': 16, 'BUTTON': 0},
+    'nina_w10': {'LED_GREEN': 33, 'LED_RED': 23, 'LED_BLUE': 21, 'SW1': 33, 'SW2': 27, 'SDA': 12,
+                 'SCL': 13, 'D0': 3, 'D1': 1, 'D2': 26, 'D3': 25, 'D4': 35, 'D5': 27, 'D6': 22,
+                 'D7': 0, 'D8': 15, 'D9': 14, 'D10': 5, 'D11': 19, 'D12': 23, 'D13': 18, 'D14': 13,
+                 'D15': 12, 'D16': 32, 'D17': 33, 'D18': 21, 'D19': 34, 'D20': 36, 'D21': 39},
+    'node32s': {},
+    'nodemcu-32s': {'LED': 2, 'BUTTON': 0},
+    'odroid_esp32': {'LED': 2, 'SDA': 15, 'SCL': 4, 'SS': 22, 'ADC1': 35, 'ADC2': 36},
+    'onehorse32dev': {'LED': 5, 'BUTTON': 0, 'A1': 37, 'A2': 38},
+    'pico32': {},
+    'pocket_32': {'LED': 16},
+    'quantum': {},
+    'ttgo-lora32-v1': {'LED': 2, 'BUTTON': 0, 'SS': 18, 'MOSI': 27, 'SCK': 5, 'A1': 37, 'A2': 38,
+                       'T8': 32, 'T9': 33, 'DAC1': 26, 'DAC2': 25, 'OLED_SDA': 4, 'OLED_SCL': 15,
+                       'OLED_RST': 16, 'LORA_SCK': 5, 'LORA_MISO': 19, 'LORA_MOSI': 27,
+                       'LORA_CS': 18, 'LORA_RST': 14, 'LORA_IRQ': 26},
+    'wemosbat': 'pocket_32',
+    'widora-air': {'LED': 25, 'BUTTON': 0, 'SDA': 23, 'SCL': 19, 'MOSI': 16, 'MISO': 17, 'A1': 39,
+                   'A2': 35, 'A3': 25, 'A4': 26, 'A5': 14, 'A6': 12, 'A7': 15, 'A8': 13, 'A9': 2,
+                   'D0': 19, 'D1': 23, 'D2': 18, 'D3': 17, 'D4': 16, 'D5': 5, 'D6': 4, 'T0': 19,
+                   'T1': 23, 'T2': 18, 'T3': 17, 'T4': 16, 'T5': 5, 'T6': 4},
+    'xinabox_cw02': {'LED': 27},
 }
 
 
+def _lookup_pin(platform, board, value):
+    if platform == ESP_PLATFORM_ESP8266:
+        board_pins = ESP8266_BOARD_PINS.get(board, {})
+        base_pins = ESP8266_BASE_PINS
+    elif platform == ESP_PLATFORM_ESP32:
+        board_pins = ESP32_BOARD_PINS.get(board, {})
+        base_pins = ESP32_BASE_PINS
+    else:
+        raise NotImplementedError
+
+    if isinstance(board_pins, str):
+        return _lookup_pin(platform, board_pins, value)
+    if value in board_pins:
+        return board_pins[value]
+    if value in base_pins:
+        return base_pins[value]
+    raise vol.Invalid(u"Can't find internal pin number for {}.".format(value))
+
+
 def _translate_pin(value):
     if isinstance(value, dict) or value is None:
-        raise vol.Invalid(u"This option doesn't allow more complicated options like inverted.")
+        raise vol.Invalid(u"This variable only supports pin numbers, not full pin schemas "
+                          u"(with inverted and mode).")
     if isinstance(value, int):
         return value
     try:
@@ -71,46 +177,26 @@ def _translate_pin(value):
     except ValueError:
         pass
     if value.startswith('GPIO'):
-        return vol.Coerce(int)(value[len('GPIO'):])
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
-        if value in ESP32_PINS:
-            return ESP32_PINS[value]
-        if cv.BOARD not in ESP32_BOARD_TO_PINS:
-            raise vol.Invalid(u"ESP32: Unknown board {} with unknown "
-                              u"pin {}.".format(cv.BOARD, value))
-        if value not in ESP32_BOARD_TO_PINS[cv.BOARD]:
-            raise vol.Invalid(u"ESP32: Board {} doesn't have"
-                              u"pin {}".format(cv.BOARD, value))
-        return ESP32_BOARD_TO_PINS[cv.BOARD][value]
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
-        if value in ESP8266_PINS:
-            return ESP8266_PINS[value]
-        if cv.BOARD not in ESP8266_BOARD_TO_PINS:
-            raise vol.Invalid(u"ESP8266: Unknown board {} with unknown "
-                              u"pin {}.".format(cv.BOARD, value))
-        if value not in ESP8266_BOARD_TO_PINS[cv.BOARD]:
-            raise vol.Invalid(u"ESP8266: Board {} doesn't have"
-                              u"pin {}".format(cv.BOARD, value))
-        return ESP8266_BOARD_TO_PINS[cv.BOARD][value]
-    raise vol.Invalid(u"Invalid ESP platform.")
+        return vol.Coerce(int)(value[len('GPIO'):].strip())
+    return _lookup_pin(core.ESP_PLATFORM, core.BOARD, value)
 
 
-def _validate_gpio_pin(value):
+def validate_gpio_pin(value):
     value = _translate_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if value < 0 or value > 39:
             raise vol.Invalid(u"ESP32: Invalid pin number: {}".format(value))
         if 6 <= value <= 11:
-            _LOGGER.warning(u"ESP32: Pin {} (6-11) might already be used by the "
-                            u"flash interface. Be warned.".format(value))
+            _LOGGER.warning(u"ESP32: Pin %s (6-11) might already be used by the "
+                            u"flash interface. Be warned.", value)
         if value in (20, 24, 28, 29, 30, 31):
-            _LOGGER.warning(u"ESP32: Pin {} (20, 24, 28-31) can usually not be used. "
-                            u"Be warned.".format(value))
+            _LOGGER.warning(u"ESP32: Pin %s (20, 24, 28-31) can usually not be used. "
+                            u"Be warned.", value)
         return value
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         if 6 <= value <= 11:
-            _LOGGER.warning(u"ESP8266: Pin {} (6-11) might already be used by the "
-                            u"flash interface. Be warned.".format(value))
+            _LOGGER.warning(u"ESP8266: Pin %s (6-11) might already be used by the "
+                            u"flash interface. Be warned.", value)
         if value < 0 or value > 17:
             raise vol.Invalid(u"ESP8266: Invalid pin number: {}".format(value))
         return value
@@ -118,41 +204,40 @@ def _validate_gpio_pin(value):
 
 
 def input_pin(value):
-    value = _validate_gpio_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    value = validate_gpio_pin(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         return value
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         return value
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
 def output_pin(value):
-    value = _validate_gpio_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    value = validate_gpio_pin(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if 34 <= value <= 39:
             raise vol.Invalid(u"ESP32: Pin {} (34-39) can only be used as "
                               u"input pins.".format(value))
         return value
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
-        if value == 16:
-            raise vol.Invalid(u"Pin {} doesn't support output mode".format(value))
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         return value
     raise vol.Invalid("Invalid ESP platform.")
 
 
 def analog_pin(value):
-    value = _validate_gpio_pin(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    value = validate_gpio_pin(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
         if 32 <= value <= 39:  # ADC1
             return value
         raise vol.Invalid(u"ESP32: Only pins 32 though 39 support ADC.")
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
         if value == 17:  # A0
             return value
         raise vol.Invalid(u"ESP8266: Only pin A0 (17) supports ADC.")
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
+# pylint: disable=invalid-name
 input_output_pin = vol.All(input_pin, output_pin)
 gpio_pin = vol.Any(input_pin, output_pin)
 PIN_MODES_ESP8266 = [
@@ -170,27 +255,74 @@ PIN_MODES_ESP32 = [
 
 def pin_mode(value):
     value = vol.All(vol.Coerce(str), vol.Upper)(value)
-    if cv.ESP_PLATFORM == ESP_PLATFORM_ESP32:
-        return vol.Any(*PIN_MODES_ESP32)(value)
-    elif cv.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
-        return vol.Any(*PIN_MODES_ESP8266)(value)
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        return cv.one_of(*PIN_MODES_ESP32)(value)
+    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+        return cv.one_of(*PIN_MODES_ESP8266)(value)
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
-GPIO_PIN_SCHEMA = vol.Schema({
-    vol.Required(CONF_NUMBER): gpio_pin,
-    vol.Required(CONF_MODE): pin_mode,
-    vol.Optional(CONF_INVERTED): cv.boolean,
-})
-
-GPIO_OUTPUT_PIN_SCHEMA = vol.Any(output_pin, vol.Schema({
+GPIO_FULL_OUTPUT_PIN_SCHEMA = vol.Schema({
     vol.Required(CONF_NUMBER): output_pin,
     vol.Optional(CONF_MODE): pin_mode,
     vol.Optional(CONF_INVERTED): cv.boolean,
-}))
+})
 
-GPIO_INPUT_PIN_SCHEMA = vol.Any(input_pin, vol.Schema({
-    vol.Required(CONF_NUMBER): input_pin,
+GPIO_FULL_INPUT_PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_NUMBER): output_pin,
     vol.Optional(CONF_MODE): pin_mode,
     vol.Optional(CONF_INVERTED): cv.boolean,
-}))
+})
+
+
+def shorthand_output_pin(value):
+    value = output_pin(value)
+    return {CONF_NUMBER: value}
+
+
+def shorthand_input_pin(value):
+    value = input_pin(value)
+    return {CONF_NUMBER: value}
+
+
+I2CDevice = esphomelib_ns.class_('I2CDevice')
+PCF8574Component = io_ns.class_('PCF8574Component', Component, I2CDevice)
+
+PCF8574_OUTPUT_PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_PCF8574): cv.use_variable_id(PCF8574Component),
+    vol.Required(CONF_NUMBER): vol.Coerce(int),
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, cv.one_of("OUTPUT")),
+    vol.Optional(CONF_INVERTED, default=False): cv.boolean,
+})
+
+PCF8574_INPUT_PIN_SCHEMA = PCF8574_OUTPUT_PIN_SCHEMA.extend({
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, cv.one_of("INPUT", "INPUT_PULLUP")),
+})
+
+
+def internal_gpio_output_pin_schema(value):
+    if isinstance(value, dict):
+        return GPIO_FULL_OUTPUT_PIN_SCHEMA(value)
+    return shorthand_output_pin(value)
+
+
+def gpio_output_pin_schema(value):
+    if isinstance(value, dict):
+        if CONF_PCF8574 in value:
+            return PCF8574_OUTPUT_PIN_SCHEMA(value)
+        return GPIO_FULL_OUTPUT_PIN_SCHEMA(value)
+    return shorthand_output_pin(value)
+
+
+def internal_gpio_input_pin_schema(value):
+    if isinstance(value, dict):
+        return GPIO_FULL_INPUT_PIN_SCHEMA(value)
+    return shorthand_input_pin(value)
+
+
+def gpio_input_pin_schema(value):
+    if isinstance(value, dict):
+        if CONF_PCF8574 in value:
+            return PCF8574_INPUT_PIN_SCHEMA(value)
+        return GPIO_FULL_INPUT_PIN_SCHEMA(value)
+    return shorthand_input_pin(value)

esphomeyaml/platformio.ini

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

esphomeyaml/platformio_api.py

@@ -0,0 +1,211 @@
+import json
+import logging
+import re
+import subprocess
+
+from esphomeyaml.const import CONF_BUILD_PATH, CONF_ESPHOMEYAML
+from esphomeyaml.helpers import relative_path
+from esphomeyaml.util import run_external_command
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def run_platformio_cli(*args, **kwargs):
+    import platformio.__main__
+
+    cmd = ['platformio'] + list(args)
+    return run_external_command(platformio.__main__.main,
+                                *cmd, **kwargs)
+
+
+def run_platformio_cli_run(config, verbose, *args, **kwargs):
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    command = ['run', '-d', build_path]
+    if verbose:
+        command += ['-v']
+    command += list(args)
+    return run_platformio_cli(*command, **kwargs)
+
+
+def run_compile(config, verbose):
+    return run_platformio_cli_run(config, verbose)
+
+
+def run_upload(config, verbose, port):
+    return run_platformio_cli_run(config, verbose, '-t', 'upload', '--upload-port', port)
+
+
+def run_idedata(config):
+    args = ['-t', 'idedata']
+    stdout = run_platformio_cli_run(config, False, *args, capture_stdout=True)
+    match = re.search(r'{.*}', stdout)
+    if match is None:
+        return IDEData(None)
+    try:
+        return IDEData(json.loads(match.group()))
+    except ValueError:
+        return IDEData(None)
+
+
+IDE_DATA = None
+
+
+def get_idedata(config):
+    global IDE_DATA
+
+    if IDE_DATA is None:
+        _LOGGER.info("Need to fetch platformio IDE-data, please stand by")
+        IDE_DATA = run_idedata(config)
+    return IDE_DATA
+
+
+# ESP logs stack trace decoder, based on https://github.com/me-no-dev/EspExceptionDecoder
+ESP8266_EXCEPTION_CODES = {
+    0: "Illegal instruction",
+    1: "SYSCALL instruction",
+    2: "InstructionFetchError: Processor internal physical address or data error during "
+       "instruction fetch",
+    3: "LoadStoreError: Processor internal physical address or data error during load or store",
+    4: "Level1Interrupt: Level-1 interrupt as indicated by set level-1 bits in the INTERRUPT "
+       "register",
+    5: "Alloca: MOVSP instruction, if caller's registers are not in the register file",
+    6: "IntegerDivideByZero: QUOS, QUOU, REMS, or REMU divisor operand is zero",
+    7: "reserved",
+    8: "Privileged: Attempt to execute a privileged operation when CRING ? 0",
+    9: "LoadStoreAlignmentCause: Load or store to an unaligned address",
+    10: "reserved",
+    11: "reserved",
+    12: "InstrPIFDataError: PIF data error during instruction fetch",
+    13: "LoadStorePIFDataError: Synchronous PIF data error during LoadStore access",
+    14: "InstrPIFAddrError: PIF address error during instruction fetch",
+    15: "LoadStorePIFAddrError: Synchronous PIF address error during LoadStore access",
+    16: "InstTLBMiss: Error during Instruction TLB refill",
+    17: "InstTLBMultiHit: Multiple instruction TLB entries matched",
+    18: "InstFetchPrivilege: An instruction fetch referenced a virtual address at a ring level "
+        "less than CRING",
+    19: "reserved",
+    20: "InstFetchProhibited: An instruction fetch referenced a page mapped with an attribute "
+        "that does not permit instruction fetch",
+    21: "reserved",
+    22: "reserved",
+    23: "reserved",
+    24: "LoadStoreTLBMiss: Error during TLB refill for a load or store",
+    25: "LoadStoreTLBMultiHit: Multiple TLB entries matched for a load or store",
+    26: "LoadStorePrivilege: A load or store referenced a virtual address at a ring level less "
+        "than ",
+    27: "reserved",
+    28: "LoadProhibited: A load referenced a page mapped with an attribute that does not permit "
+        "loads",
+    29: "StoreProhibited: A store referenced a page mapped with an attribute that does not permit "
+        "stores",
+}
+
+
+def _decode_pc(config, addr):
+    idedata = get_idedata(config)
+    if not idedata.addr2line_path or not idedata.firmware_elf_path:
+        return
+    command = [idedata.addr2line_path, '-pfiaC', '-e', idedata.firmware_elf_path, addr]
+    try:
+        translation = subprocess.check_output(command).strip()
+    except Exception:  # pylint: disable=broad-except
+        return
+
+    if "?? ??:0" in translation:
+        # Nothing useful
+        return
+    translation = translation.replace(' at ??:?', '').replace(':?', '')
+    _LOGGER.warning("Decoded %s", translation)
+
+
+def _parse_register(config, regex, line):
+    match = regex.match(line)
+    if match is not None:
+        _decode_pc(config, match.group(1))
+
+
+STACKTRACE_ESP8266_EXCEPTION_TYPE_RE = re.compile(r'Exception \(([0-9]*)\):')
+STACKTRACE_ESP8266_PC_RE = re.compile(r'epc1=0x(4[0-9a-fA-F]{7})')
+STACKTRACE_ESP8266_EXCVADDR_RE = re.compile(r'excvaddr=0x(4[0-9a-fA-F]{7})')
+STACKTRACE_ESP32_PC_RE = re.compile(r'PC\s*:\s*(?:0x)?(4[0-9a-fA-F]{7})')
+STACKTRACE_ESP32_EXCVADDR_RE = re.compile(r'EXCVADDR\s*:\s*(?:0x)?(4[0-9a-fA-F]{7})')
+STACKTRACE_BAD_ALLOC_RE = re.compile(r'^last failed alloc call: (4[0-9a-fA-F]{7})\((\d+)\)$')
+STACKTRACE_ESP32_BACKTRACE_RE = re.compile(r'Backtrace:(?:\s+0x4[0-9a-fA-F]{7}:0x3[0-9a-fA-F]{7})+')
+STACKTRACE_ESP32_BACKTRACE_PC_RE = re.compile(r'4[0-9a-f]{7}')
+STACKTRACE_ESP8266_BACKTRACE_PC_RE = re.compile(r'4[0-9a-f]{7}')
+
+
+def process_stacktrace(config, line, backtrace_state):
+    line = line.strip()
+    # ESP8266 Exception type
+    match = re.match(STACKTRACE_ESP8266_EXCEPTION_TYPE_RE, line)
+    if match is not None:
+        code = match.group(1)
+        _LOGGER.warning("Exception type: %s", ESP8266_EXCEPTION_CODES.get(code, 'unknown'))
+
+    # ESP8266 PC/EXCVADDR
+    _parse_register(config, STACKTRACE_ESP8266_PC_RE, line)
+    _parse_register(config, STACKTRACE_ESP8266_EXCVADDR_RE, line)
+    # ESP32 PC/EXCVADDR
+    _parse_register(config, STACKTRACE_ESP32_PC_RE, line)
+    _parse_register(config, STACKTRACE_ESP32_EXCVADDR_RE, line)
+
+    # bad alloc
+    match = re.match(STACKTRACE_BAD_ALLOC_RE, line)
+    if match is not None:
+        _LOGGER.warning("Memory allocation of %s bytes failed at %s",
+                        match.group(2), match.group(1))
+        _decode_pc(config, match.group(1))
+
+    # ESP32 single-line backtrace
+    match = re.match(STACKTRACE_ESP32_BACKTRACE_RE, line)
+    if match is not None:
+        _LOGGER.warning("Found stack trace! Trying to decode it")
+        for addr in re.finditer(STACKTRACE_ESP32_BACKTRACE_PC_RE, line):
+            _decode_pc(config, addr.group())
+
+    # ESP8266 multi-line backtrace
+    if '>>>stack>>>' in line:
+        # Start of backtrace
+        backtrace_state = True
+        _LOGGER.warning("Found stack trace! Trying to decode it")
+    elif '<<<stack<<<' in line:
+        # End of backtrace
+        backtrace_state = False
+
+    if backtrace_state:
+        for addr in re.finditer(STACKTRACE_ESP8266_BACKTRACE_PC_RE, line):
+            _decode_pc(config, addr.group())
+
+    return backtrace_state
+
+
+class IDEData(object):
+    def __init__(self, raw):
+        if not isinstance(raw, dict):
+            self.raw = {}
+        else:
+            self.raw = raw
+
+    @property
+    def firmware_elf_path(self):
+        return self.raw.get("prog_path")
+
+    @property
+    def flash_extra_images(self):
+        return [
+            (x['path'], x['offset']) for x in self.raw.get("flash_extra_images", [])
+        ]
+
+    @property
+    def cc_path(self):
+        # For example /Users/<USER>/.platformio/packages/toolchain-xtensa32/bin/xtensa-esp32-elf-gcc
+        return self.raw.get("cc_path")
+
+    @property
+    def addr2line_path(self):
+        cc_path = self.cc_path
+        if cc_path is None:
+            return None
+        # replace gcc at end with addr2line
+        return cc_path[:-3] + 'addr2line'

esphomeyaml/util.py

@@ -0,0 +1,83 @@
+from __future__ import print_function
+
+import io
+import logging
+import re
+import sys
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Registry(dict):
+    def register(self, name):
+        def decorator(fun):
+            self[name] = fun
+            return fun
+
+        return decorator
+
+
+class ServiceRegistry(dict):
+    def register(self, name, validator):
+        def decorator(fun):
+            self[name] = (validator, fun)
+            return fun
+
+        return decorator
+
+
+def safe_print(message=""):
+    try:
+        print(message)
+        return
+    except UnicodeEncodeError:
+        pass
+
+    try:
+        print(message.encode('ascii', 'backslashreplace'))
+    except UnicodeEncodeError:
+        print("Cannot print line because of invalid locale!")
+
+
+def shlex_quote(s):
+    if not s:
+        return u"''"
+    if re.search(r'[^\w@%+=:,./-]', s) is None:
+        return s
+
+    return u"'" + s.replace(u"'", u"'\"'\"'") + u"'"
+
+
+def run_external_command(func, *cmd, **kwargs):
+    def mock_exit(return_code):
+        raise SystemExit(return_code)
+
+    orig_argv = sys.argv
+    orig_exit = sys.exit  # mock sys.exit
+    full_cmd = u' '.join(shlex_quote(x) for x in cmd)
+    _LOGGER.info(u"Running:  %s", full_cmd)
+
+    capture_stdout = kwargs.get('capture_stdout', False)
+    if capture_stdout:
+        sys.stdout = io.BytesIO()
+
+    try:
+        sys.argv = list(cmd)
+        sys.exit = mock_exit
+        return func() or 0
+    except KeyboardInterrupt:
+        return 1
+    except SystemExit as err:
+        return err.args[0]
+    except Exception as err:  # pylint: disable=broad-except
+        _LOGGER.error(u"Running command failed: %s", err)
+        _LOGGER.error(u"Please try running %s locally.", full_cmd)
+    finally:
+        sys.argv = orig_argv
+        sys.exit = orig_exit
+
+        if capture_stdout:
+            # pylint: disable=lost-exception
+            stdout = sys.stdout.getvalue()
+            sys.stdout = sys.__stdout__
+            return stdout

esphomeyaml/wizard.py

@@ -2,54 +2,56 @@ from __future__ import print_function
 
 import codecs
 import os
-from time import sleep
 import unicodedata
 
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
 from esphomeyaml.components import mqtt
-from esphomeyaml.const import ESP_PLATFORMS, ESP_PLATFORM_ESP32, ESP_BOARDS_FOR_PLATFORM
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import ESP_PLATFORMS, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
 from esphomeyaml.helpers import color
+# pylint: disable=anomalous-backslash-in-string
+from esphomeyaml.pins import ESP32_BOARD_PINS, ESP8266_BOARD_PINS
+from esphomeyaml.util import safe_print
 
-CORE_BIG = """    _____ ____  _____  ______ 
+CORE_BIG = """    _____ ____  _____  ______
    / ____/ __ \|  __ \|  ____|
-  | |   | |  | | |__) | |__   
-  | |   | |  | |  _  /|  __|  
-  | |___| |__| | | \ \| |____ 
+  | |   | |  | | |__) | |__
+  | |   | |  | |  _  /|  __|
+  | |___| |__| | | \ \| |____
    \_____\____/|_|  \_\______|
 """
-ESP_BIG = """      ______  _____ _____  
-     |  ____|/ ____|  __ \ 
+ESP_BIG = """      ______  _____ _____
+     |  ____|/ ____|  __ \\
      | |__  | (___ | |__) |
-     |  __|  \___ \|  ___/ 
-     | |____ ____) | |     
-     |______|_____/|_|     
+     |  __|  \___ \|  ___/
+     | |____ ____) | |
+     |______|_____/|_|
 """
-WIFI_BIG = """   __          ___ ______ _ 
+WIFI_BIG = """   __          ___ ______ _
    \ \        / (_)  ____(_)
-    \ \  /\  / / _| |__   _ 
+    \ \  /\  / / _| |__   _
      \ \/  \/ / | |  __| | |
       \  /\  /  | | |    | |
        \/  \/   |_|_|    |_|
 """
-MQTT_BIG = """   __  __  ____ _______ _______ 
+MQTT_BIG = """   __  __  ____ _______ _______
   |  \/  |/ __ \__   __|__   __|
-  | \  / | |  | | | |     | |   
-  | |\/| | |  | | | |     | |   
-  | |  | | |__| | | |     | |   
-  |_|  |_|\___\_\ |_|     |_|   
+  | \  / | |  | | | |     | |
+  | |\/| | |  | | | |     | |
+  | |  | | |__| | | |     | |
+  |_|  |_|\___\_\ |_|     |_|
 """
-OTA_BIG = """       ____ _______       
-      / __ \__   __|/\    
-     | |  | | | |  /  \   
-     | |  | | | | / /\ \  
-     | |__| | | |/ ____ \ 
+OTA_BIG = """       ____ _______
+      / __ \__   __|/\\
+     | |  | | | |  /  \\
+     | |  | | | | / /\ \\
+     | |__| | | |/ ____ \\
       \____/  |_/_/    \_\\
 """
 
 # TODO handle escaping
-BASE_CONFIG = """esphomeyaml:
+BASE_CONFIG = u"""esphomeyaml:
   name: {name}
   platform: {platform}
   board: {board}
@@ -69,53 +71,71 @@ logger:
 """
 
 
-def print_step(step, big):
-    print()
-    print()
-    print("============= STEP {} =============".format(step))
-    print(big)
-    print("===================================")
+def wizard_file(**kwargs):
+    config = BASE_CONFIG.format(**kwargs)
+
+    if kwargs['ota_password']:
+        config += u"ota:\n  password: '{}'\n".format(kwargs['ota_password'])
+    else:
+        config += u"ota:\n"
+
+    return config
+
+
+if os.getenv('ESPHOMEYAML_QUICKWIZARD', False):
+    def sleep(time):
+        pass
+else:
+    from time import sleep
+
+
+def safe_print_step(step, big):
+    safe_print()
+    safe_print()
+    safe_print("============= STEP {} =============".format(step))
+    safe_print(big)
+    safe_print("===================================")
     sleep(0.25)
 
 
 def default_input(text, default):
-    print()
-    print("Press ENTER for default ({})".format(default))
+    safe_print()
+    safe_print(u"Press ENTER for default ({})".format(default))
     return raw_input(text.format(default)) or default
 
 
 # From https://stackoverflow.com/a/518232/8924614
-def strip_accents(s):
-    return u''.join(c for c in unicodedata.normalize('NFD', unicode(s))
+def strip_accents(string):
+    return u''.join(c for c in unicodedata.normalize('NFD', unicode(string))
                     if unicodedata.category(c) != 'Mn')
 
 
 def wizard(path):
     if not path.endswith('.yaml') and not path.endswith('.yml'):
-        print("Please make your configuration file {} have the extension .yaml or .yml".format(
-            color('cyan', path)))
+        safe_print(u"Please make your configuration file {} have the extension .yaml or .yml"
+                   u"".format(color('cyan', path)))
         return 1
     if os.path.exists(path):
-        print("Uh oh, it seems like {} already exists, please delete that file first "
-              "or chose another configuration file.".format(color('cyan', path)))
+        safe_print(u"Uh oh, it seems like {} already exists, please delete that file first "
+                   u"or chose another configuration file.".format(color('cyan', path)))
         return 1
-    print("Hi there!")
+    safe_print("Hi there!")
     sleep(1.5)
-    print("I'm the wizard of esphomeyaml :)")
+    safe_print("I'm the wizard of esphomeyaml :)")
     sleep(1.25)
-    print("And I'm here to help you get started with esphomeyaml.")
+    safe_print("And I'm here to help you get started with esphomeyaml.")
     sleep(2.0)
-    print("In 5 steps I'm going to guide you through creating a basic "
-          "configuration file for your custom ESP8266/ESP32 firmware. Yay!")
+    safe_print("In 5 steps I'm going to guide you through creating a basic "
+               "configuration file for your custom ESP8266/ESP32 firmware. Yay!")
     sleep(3.0)
-    print()
-    print_step(1, CORE_BIG)
-    print("First up, please choose a " + color('green', 'name') + " for your node.")
-    print("It should be a unique name that can be used to identify the device later.")
+    safe_print()
+    safe_print_step(1, CORE_BIG)
+    safe_print("First up, please choose a " + color('green', 'name') + " for your node.")
+    safe_print("It should be a unique name that can be used to identify the device later.")
     sleep(1)
-    print("For example, I like calling the node in my living room {}.".format(
+    safe_print("For example, I like calling the node in my living room {}.".format(
         color('bold_white', "livingroom")))
-    print()
+    safe_print()
     sleep(1)
     name = raw_input(color("bold_white", "(name): "))
     while True:
@@ -123,34 +143,34 @@ def wizard(path):
             name = cv.valid_name(name)
             break
         except vol.Invalid:
-            print(color("red", "Oh noes, \"{}\" isn't a valid name. Names can only include "
-                               "numbers, letters and underscores.".format(name)))
+            safe_print(color("red", u"Oh noes, \"{}\" isn't a valid name. Names can only include "
+                                    u"numbers, letters and underscores.".format(name)))
             name = strip_accents(name).replace(' ', '_')
             name = u''.join(c for c in name if c in cv.ALLOWED_NAME_CHARS)
-            print("Shall I use \"{}\" as the name instead?".format(color('cyan', name)))
+            safe_print(u"Shall I use \"{}\" as the name instead?".format(color('cyan', name)))
             sleep(0.5)
-            name = default_input("(name [{}]): ", name)
+            name = default_input(u"(name [{}]): ", name)
 
-    print("Great! Your node is now called \"{}\".".format(color('cyan', name)))
+    safe_print(u"Great! Your node is now called \"{}\".".format(color('cyan', name)))
     sleep(1)
-    print_step(2, ESP_BIG)
-    print("Now I'd like to know which *board* you're using so that I can compile "
-          "firmwares for it.")
-    print("Are you using an " + color('green', 'ESP32') + " or " +
-          color('green', 'ESP8266') + " based board?")
+    safe_print_step(2, ESP_BIG)
+    safe_print("Now I'd like to know what microcontroller you're using so that I can compile "
+               "firmwares for it.")
+    safe_print("Are you using an " + color('green', 'ESP32') + " or " +
+               color('green', 'ESP8266') + " platform? (Choose ESP8266 for Sonoff devices)")
     while True:
         sleep(0.5)
-        print()
-        print("Please enter either ESP32 or ESP8266.")
+        safe_print()
+        safe_print("Please enter either ESP32 or ESP8266.")
         platform = raw_input(color("bold_white", "(ESP32/ESP8266): "))
         try:
             platform = vol.All(vol.Upper, vol.Any(*ESP_PLATFORMS))(platform)
             break
         except vol.Invalid:
-            print("Unfortunately, I can't find an espressif microcontroller called "
-                  "\"{}\". Please try again.".format(platform))
-    print("Thanks! You've chosen {} as your platform.".format(color('cyan', platform)))
-    print()
+            safe_print(u"Unfortunately, I can't find an espressif microcontroller called "
+                       u"\"{}\". Please try again.".format(platform))
+    safe_print(u"Thanks! You've chosen {} as your platform.".format(color('cyan', platform)))
+    safe_print()
     sleep(1)
 
     if platform == ESP_PLATFORM_ESP32:
@@ -158,87 +178,92 @@ def wizard(path):
     else:
         board_link = 'http://docs.platformio.org/en/latest/platforms/espressif8266.html#boards'
 
-    print("Next, I need to know what " + color('green', 'board') + " you're using.")
+    safe_print("Next, I need to know what " + color('green', 'board') + " you're using.")
     sleep(0.5)
-    print("Please go to {} and choose a board.".format(color('green', board_link)))
-    print()
+    safe_print("Please go to {} and choose a board.".format(color('green', board_link)))
+    if platform == ESP_PLATFORM_ESP8266:
+        safe_print("(Type " + color('green', 'esp01_1m') + " for Sonoff devices)")
+    safe_print()
     # Don't sleep because user needs to copy link
     if platform == ESP_PLATFORM_ESP32:
-        print("For example \"{}\".".format(color("bold_white", 'nodemcu-32s')))
+        safe_print("For example \"{}\".".format(color("bold_white", 'nodemcu-32s')))
+        boards = list(ESP32_BOARD_PINS.keys())
     else:
-        print("For example \"{}\".".format(color("bold_white", 'nodemcuv2')))
+        safe_print("For example \"{}\".".format(color("bold_white", 'nodemcuv2')))
+        boards = list(ESP8266_BOARD_PINS.keys())
     while True:
         board = raw_input(color("bold_white", "(board): "))
-        boards = ESP_BOARDS_FOR_PLATFORM[platform]
         try:
             board = vol.All(vol.Lower, vol.Any(*boards))(board)
             break
         except vol.Invalid:
-            print(color('red', "Sorry, I don't think the board \"{}\" exists."))
-            print()
+            safe_print(color('red', "Sorry, I don't think the board \"{}\" exists."))
+            safe_print()
             sleep(0.25)
-            print("Possible options are {}".format(', '.join(boards)))
-            print()
+            safe_print("Possible options are {}".format(', '.join(boards)))
+            safe_print()
 
-    print("Way to go! You've chosen {} as your board.".format(color('cyan', board)))
-    print()
+    safe_print(u"Way to go! You've chosen {} as your board.".format(color('cyan', board)))
+    safe_print()
     sleep(1)
 
-    print_step(3, WIFI_BIG)
-    print("In this step, I'm going to create the configuration for "
-          "WiFi.")
-    print()
+    safe_print_step(3, WIFI_BIG)
+    safe_print("In this step, I'm going to create the configuration for "
+               "WiFi.")
+    safe_print()
     sleep(1)
-    print("First, what's the " + color('green', 'SSID') + " (the name) of the WiFi network {} "
-          "I should connect to?".format(name))
+    safe_print("First, what's the " + color('green', 'SSID') +
+               u" (the name) of the WiFi network {} I should connect to?".format(name))
     sleep(1.5)
-    print("For example \"{}\".".format(color('bold_white', "Abraham Linksys")))
+    safe_print("For example \"{}\".".format(color('bold_white', "Abraham Linksys")))
     while True:
         ssid = raw_input(color('bold_white', "(ssid): "))
         try:
             ssid = cv.ssid(ssid)
             break
         except vol.Invalid:
-            print(color('red', "Unfortunately, \"{}\" doesn't seem to be a valid SSID. "
-                  "Please try again.".format(ssid)))
-            print()
+            safe_print(color('red', u"Unfortunately, \"{}\" doesn't seem to be a valid SSID. "
+                                    u"Please try again.".format(ssid)))
+            safe_print()
             sleep(1)
 
-    print("Thank you very much! You've just chosen \"{}\" as your SSID.".format(
-        color('cyan', ssid)))
-    print()
+    safe_print(u"Thank you very much! You've just chosen \"{}\" as your SSID."
+               u"".format(color('cyan', ssid)))
+    safe_print()
     sleep(0.75)
 
-    print("Now please state the " + color('green', 'password') +
-          " of the WiFi network so that I can connect to it.")
-    print()
-    print("For example \"{}\"".format(color('bold_white', 'PASSWORD42')))
+    safe_print("Now please state the " + color('green', 'password') +
+               " of the WiFi network so that I can connect to it (Leave empty for no password)")
+    safe_print()
+    safe_print("For example \"{}\"".format(color('bold_white', 'PASSWORD42')))
     sleep(0.5)
     psk = raw_input(color('bold_white', '(PSK): '))
-    print("Perfect! WiFi is now set up (you can create static IPs and so on later).")
+    safe_print("Perfect! WiFi is now set up (you can create static IPs and so on later).")
     sleep(1.5)
 
-    print_step(4, MQTT_BIG)
-    print("Almost there! Now let's setup MQTT so that your node can connect to the outside world.")
-    print()
+    safe_print_step(4, MQTT_BIG)
+    safe_print("Almost there! Now let's setup MQTT so that your node can connect to the "
+               "outside world.")
+    safe_print()
     sleep(1)
-    print("Please enter the " + color('green', 'address') + " of your MQTT broker.")
-    print()
-    print("For example \"{}\".".format(color('bold_white', '192.168.178.84')))
+    safe_print("Please enter the " + color('green', 'address') + " of your MQTT broker.")
+    safe_print()
+    safe_print("For example \"{}\".".format(color('bold_white', '192.168.178.84')))
     while True:
         broker = raw_input(color('bold_white', "(broker): "))
         try:
             broker = mqtt.validate_broker(broker)
             break
-        except vol.Invalid as e:
-            print(color('red', "The broker address \"{}\" seems to be invalid: {} :(".format(
-                broker, e)))
-            print("Please try again.")
-            print()
+        except vol.Invalid as err:
+            safe_print(color('red', u"The broker address \"{}\" seems to be invalid: {} :("
+                                    u"".format(broker, err)))
+            safe_print("Please try again.")
+            safe_print()
             sleep(1)
 
-    print("Thanks! Now enter the " + color('green', 'username') + " and " +
-          color('green', 'password') + " for the MQTT broker. Leave empty for no authentication.")
+    safe_print("Thanks! Now enter the " + color('green', 'username') + " and " +
+               color('green', 'password') +
+               " for the MQTT broker. Leave empty for no authentication.")
     mqtt_username = raw_input(color('bold_white', '(username): '))
     mqtt_password = ''
     if mqtt_username:
@@ -247,47 +272,42 @@ def wizard(path):
         show = '*' * len(mqtt_password)
         if len(mqtt_password) >= 2:
             show = mqtt_password[:2] + '*' * len(mqtt_password)
-        print("MQTT Username: \"{}\"; Password: \"{}\"".format(
-            color('cyan', mqtt_username), color('cyan', show)))
+        safe_print(u"MQTT Username: \"{}\"; Password: \"{}\""
+                   u"".format(color('cyan', mqtt_username), color('cyan', show)))
     else:
-        print("No authentication for MQTT")
+        safe_print("No authentication for MQTT")
 
-    print_step(5, OTA_BIG)
-    print("Last step! esphomeyaml can automatically upload custom firmwares over WiFi "
-          "(over the air).")
-    print("This can be insecure if you do not trust the WiFi network. Do you want to set "
-          "an " + color('green', 'OTA password') + " for remote updates?")
-    print()
+    safe_print_step(5, OTA_BIG)
+    safe_print("Last step! esphomeyaml can automatically upload custom firmwares over WiFi "
+               "(over the air).")
+    safe_print("This can be insecure if you do not trust the WiFi network. Do you want to set "
+               "an " + color('green', 'OTA password') + " for remote updates?")
+    safe_print()
     sleep(0.25)
-    print("Press ENTER for no password")
+    safe_print("Press ENTER for no password")
     ota_password = raw_input(color('bold_white', '(password): '))
 
-    config = BASE_CONFIG.format(name=name, platform=platform, board=board,
-                                ssid=ssid, psk=psk, broker=broker,
-                                mqtt_username=mqtt_username, mqtt_password=mqtt_password)
+    config = wizard_file(name=name, platform=platform, board=board,
+                         ssid=ssid, psk=psk, broker=broker,
+                         mqtt_username=mqtt_username, mqtt_password=mqtt_password,
+                         ota_password=ota_password)
 
-    if ota_password:
-        config += "ota:\n  password: '{}'\n".format(ota_password)
-    else:
-        config += "ota:\n"
+    with codecs.open(path, 'w') as f_handle:
+        f_handle.write(config)
 
-    with codecs.open(path, 'w') as f:
-        f.write(config)
-
-    print()
-    print(color('cyan', "DONE! I've now written a new configuration file to ") +
-          color('bold_cyan', path))
-    print()
-    print("Next steps:")
-    print("  > If you haven't already, enable MQTT discovery in Home Assistant:")
-    print()
-    print(color('bold_white', "# In your configuration.yaml"))
-    print(color('bold_white', "mqtt:"))
-    print(color('bold_white', "  broker: {}".format(broker)))
-    print(color('bold_white', "  # ..."))
-    print(color('bold_white', "  discovery: True"))
-    print()
-    print("  > Then follow the rest of the getting started guide:")
-    print("  > https://esphomelib.com/esphomeyaml/getting-started.html")
+    safe_print()
+    safe_print(color('cyan', "DONE! I've now written a new configuration file to ") +
+               color('bold_cyan', path))
+    safe_print()
+    safe_print("Next steps:")
+    safe_print("  > If you haven't already, enable MQTT discovery in Home Assistant:")
+    safe_print()
+    safe_print(color('bold_white', "# In your configuration.yaml"))
+    safe_print(color('bold_white', "mqtt:"))
+    safe_print(color('bold_white', u"  broker: {}".format(broker)))
+    safe_print(color('bold_white', "  # ..."))
+    safe_print(color('bold_white', "  discovery: True"))
+    safe_print()
+    safe_print("  > Then follow the rest of the getting started guide:")
+    safe_print("  > https://esphomelib.com/esphomeyaml/guides/getting_started_command_line.html")
     return 0
-

esphomeyaml/writer.py

@@ -2,12 +2,21 @@ from __future__ import print_function
 
 import codecs
 import errno
+import json
+import logging
 import os
+import shutil
 
-from esphomeyaml.config import get_component
-from esphomeyaml.const import CONF_BOARD, CONF_ESPHOMEYAML, CONF_LIBRARY_URI, CONF_LOGGER, \
-    CONF_NAME, CONF_OTA, CONF_PLATFORM, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
+from esphomeyaml import core
+from esphomeyaml.config import iter_components
+from esphomeyaml.const import ARDUINO_VERSION_ESP32_DEV, CONF_ARDUINO_VERSION, CONF_BOARD, \
+    CONF_BOARD_FLASH_MODE, CONF_ESPHOMELIB_VERSION, CONF_ESPHOMEYAML, CONF_LOCAL, CONF_NAME, \
+    CONF_USE_CUSTOM_CODE, ESP_PLATFORM_ESP32, CONF_REPOSITORY, CONF_COMMIT, CONF_BRANCH, CONF_TAG
 from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.core_config import VERSION_REGEX
+from esphomeyaml.helpers import relative_path
+
+_LOGGER = logging.getLogger(__name__)
 
 CPP_AUTO_GENERATE_BEGIN = u'// ========== AUTO GENERATED CODE BEGIN ==========='
 CPP_AUTO_GENERATE_END = u'// =========== AUTO GENERATED CODE END ============'
@@ -28,16 +37,16 @@ void setup() {
 
 void loop() {
   App.loop();
-  delay(1);
+  delay(16);
 }
 """)
 
 INI_BASE_FORMAT = (u"""; Auto generated code by esphomeyaml
 
 [common]
-lib_deps = 
-build_flags = 
-upload_flags = 
+lib_deps =
+build_flags =
+upload_flags =
 
 ; ===== DO NOT EDIT ANYTHING BELOW THIS LINE =====
 """, u"""
@@ -50,31 +59,139 @@ platform = {platform}
 board = {board}
 framework = arduino
 lib_deps =
-    {esphomeyaml_uri}
+    {lib_deps}
     ${{common.lib_deps}}
-build_flags ={build_flags}
+build_flags =
+    {build_flags}
     ${{common.build_flags}}
+upload_speed = {upload_speed}
 """
 
-PLATFORM_TO_PLATFORMIO = {
-    ESP_PLATFORM_ESP32: 'espressif32',
-    ESP_PLATFORM_ESP8266: 'espressif8266'
+UPLOAD_SPEED_OVERRIDE = {
+    'esp210': 57600,
 }
 
 
-def get_ini_content(config):
-    d = {
+def get_build_flags(config, key):
+    build_flags = set()
+    for _, component, conf in iter_components(config):
+        if not hasattr(component, key):
+            continue
+        flags = getattr(component, key)
+        if callable(flags):
+            flags = flags(conf)
+        if flags is None:
+            continue
+        if isinstance(flags, (str, unicode)):
+            flags = [flags]
+        build_flags |= set(flags)
+    return build_flags
+
+
+def get_ini_content(config, path):
+    version_specific_settings = determine_platformio_version_settings()
+    options = {
         u'env': config[CONF_ESPHOMEYAML][CONF_NAME],
-        u'platform': PLATFORM_TO_PLATFORMIO[config[CONF_ESPHOMEYAML][CONF_PLATFORM]],
+        u'platform': config[CONF_ESPHOMEYAML][CONF_ARDUINO_VERSION],
         u'board': config[CONF_ESPHOMEYAML][CONF_BOARD],
-        u'esphomeyaml_uri': config[CONF_ESPHOMEYAML][CONF_LIBRARY_URI],
         u'build_flags': u'',
+        u'upload_speed': UPLOAD_SPEED_OVERRIDE.get(core.BOARD, 115200),
     }
-    if CONF_LOGGER in config:
-        build_flags = get_component(CONF_LOGGER).get_build_flags(config[CONF_LOGGER])
-        if build_flags:
-            d[u'build_flags'] = u'\n    ' + build_flags
-    return INI_CONTENT_FORMAT.format(**d)
+    build_flags = set()
+    if not config[CONF_ESPHOMEYAML][CONF_USE_CUSTOM_CODE]:
+        build_flags |= get_build_flags(config, 'build_flags')
+        build_flags |= get_build_flags(config, 'BUILD_FLAGS')
+        build_flags.add(u"-DESPHOMEYAML_USE")
+        build_flags.add("-Wno-unused-variable")
+        build_flags.add("-Wno-unused-but-set-variable")
+    build_flags |= get_build_flags(config, 'required_build_flags')
+    build_flags |= get_build_flags(config, 'REQUIRED_BUILD_FLAGS')
+
+    # avoid changing build flags order
+    build_flags = sorted(list(build_flags))
+    if build_flags:
+        options[u'build_flags'] = u'\n    '.join(build_flags)
+
+    lib_deps = set()
+
+    lib_version = config[CONF_ESPHOMEYAML][CONF_ESPHOMELIB_VERSION]
+    lib_path = os.path.join(path, 'lib')
+    dst_path = os.path.join(lib_path, 'esphomelib')
+    this_version = None
+    if CONF_REPOSITORY in lib_version:
+        tag = next((lib_version[x] for x in (CONF_COMMIT, CONF_BRANCH, CONF_TAG)
+                    if x in lib_version), None)
+        this_version = lib_version[CONF_REPOSITORY]
+        if tag is not None:
+            this_version += '#' + tag
+        lib_deps.add(this_version)
+        if os.path.islink(dst_path):
+            os.unlink(dst_path)
+    elif CONF_LOCAL in lib_version:
+        this_version = lib_version[CONF_LOCAL]
+        src_path = relative_path(this_version)
+        do_write = True
+        if os.path.islink(dst_path):
+            old_path = os.path.join(os.readlink(dst_path), lib_path)
+            if old_path != lib_path:
+                os.unlink(dst_path)
+            else:
+                do_write = False
+        if do_write:
+            mkdir_p(lib_path)
+            os.symlink(src_path, dst_path)
+
+        # Manually add lib_deps because platformio seems to ignore them inside libs/
+        library_json_path = os.path.join(src_path, 'library.json')
+        with codecs.open(library_json_path, 'r', encoding='utf-8') as f_handle:
+            library_json_text = f_handle.read()
+
+        library_json = json.loads(library_json_text)
+        for dep in library_json.get('dependencies', []):
+            if 'version' in dep and VERSION_REGEX.match(dep['version']) is not None:
+                lib_deps.add(dep['name'] + '@' + dep['version'])
+            else:
+                lib_deps.add(dep['version'])
+    else:
+        this_version = lib_version
+        lib_deps.add(lib_version)
+
+    version_file = os.path.join(path, '.esphomelib_version')
+    version = None
+    if os.path.isfile(version_file):
+        with open(version_file, 'r') as ver_f:
+            version = ver_f.read()
+
+    if version != this_version:
+        _LOGGER.info("Esphomelib version change detected. Cleaning build files...")
+        try:
+            clean_build(path)
+        except OSError as err:
+            _LOGGER.warn("Error deleting build files (%s)! Ignoring...", err)
+
+        with open(version_file, 'w') as ver_f:
+            ver_f.write(this_version)
+
+    lib_deps |= get_build_flags(config, 'LIB_DEPS')
+    lib_deps |= get_build_flags(config, 'lib_deps')
+    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+        lib_deps |= {
+            'Preferences',  # Preferences helper
+        }
+        # Manual fix for AsyncTCP
+        if config[CONF_ESPHOMEYAML].get(CONF_ARDUINO_VERSION) == ARDUINO_VERSION_ESP32_DEV:
+            lib_deps.add('https://github.com/me-no-dev/AsyncTCP.git#idf-update')
+    # avoid changing build flags order
+    lib_deps = sorted(x for x in lib_deps if x)
+    if lib_deps:
+        options[u'lib_deps'] = u'\n    '.join(lib_deps)
+
+    content = INI_CONTENT_FORMAT.format(**options)
+    if CONF_BOARD_FLASH_MODE in config[CONF_ESPHOMEYAML]:
+        flash_mode_key = version_specific_settings['flash_mode_key']
+        flash_mode = config[CONF_ESPHOMEYAML][CONF_BOARD_FLASH_MODE]
+        content += "{} = {}\n".format(flash_mode_key, flash_mode)
+    return content
 
 
 def mkdir_p(path):
@@ -109,29 +226,47 @@ def find_begin_end(text, begin_s, end_s):
 def write_platformio_ini(content, path):
     if os.path.isfile(path):
         try:
-            with codecs.open(path, 'r', encoding='utf-8') as f:
-                text = f.read()
+            with codecs.open(path, 'r', encoding='utf-8') as f_handle:
+                text = f_handle.read()
         except OSError:
             raise ESPHomeYAMLError(u"Could not read ini file at {}".format(path))
         prev_file = text
         content_format = find_begin_end(text, INI_AUTO_GENERATE_BEGIN, INI_AUTO_GENERATE_END)
     else:
         prev_file = None
-        mkdir_p(os.path.dirname(path))
         content_format = INI_BASE_FORMAT
     full_file = content_format[0] + INI_AUTO_GENERATE_BEGIN + '\n' + \
         content + INI_AUTO_GENERATE_END + content_format[1]
     if prev_file == full_file:
         return
-    with codecs.open(path, mode='w+', encoding='utf-8') as f:
-        f.write(full_file)
+    with codecs.open(path, mode='w+', encoding='utf-8') as f_handle:
+        f_handle.write(full_file)
+
+
+def write_platformio_project(config, path):
+    mkdir_p(path)
+    platformio_ini = os.path.join(path, 'platformio.ini')
+    content = get_ini_content(config, path)
+    if 'esp32_ble_beacon' in config or 'esp32_ble_tracker' in config:
+        content += 'board_build.partitions = partitions.csv\n'
+        partitions_csv = os.path.join(path, 'partitions.csv')
+        if not os.path.isfile(partitions_csv):
+            mkdir_p(path)
+            with open(partitions_csv, "w") as f:
+                f.write("nvs,      data, nvs,     0x009000, 0x005000,\n")
+                f.write("otadata,  data, ota,     0x00e000, 0x002000,\n")
+                f.write("app0,     app,  ota_0,   0x010000, 0x190000,\n")
+                f.write("app1,     app,  ota_1,   0x200000, 0x190000,\n")
+                f.write("eeprom,   data, 0x99,    0x390000, 0x001000,\n")
+                f.write("spiffs,   data, spiffs,  0x391000, 0x00F000\n")
+    write_platformio_ini(content, platformio_ini)
 
 
 def write_cpp(code_s, path):
     if os.path.isfile(path):
         try:
-            with codecs.open(path, 'r', encoding='utf-8') as f:
-                text = f.read()
+            with codecs.open(path, 'r', encoding='utf-8') as f_handle:
+                text = f_handle.read()
         except OSError:
             raise ESPHomeYAMLError(u"Could not read C++ file at {}".format(path))
         prev_file = text
@@ -145,5 +280,26 @@ def write_cpp(code_s, path):
         code_s + CPP_AUTO_GENERATE_END + code_format[1]
     if prev_file == full_file:
         return
-    with codecs.open(path, 'w+', encoding='utf-8') as f:
-        f.write(full_file)
+    with codecs.open(path, 'w+', encoding='utf-8') as f_handle:
+        f_handle.write(full_file)
+
+
+def determine_platformio_version_settings():
+    import platformio
+
+    settings = {}
+
+    if platformio.VERSION < (3, 5, 3):
+        settings['flash_mode_key'] = 'board_flash_mode'
+    else:
+        settings['flash_mode_key'] = 'board_build.flash_mode'
+
+    return settings
+
+
+def clean_build(build_path):
+    for directory in ('.piolibdeps', '.pioenvs'):
+        dir_path = os.path.join(build_path, directory)
+        if os.path.isdir(dir_path):
+            _LOGGER.info("Deleting %s", dir_path)
+            shutil.rmtree(dir_path)

esphomeyaml/yaml_util.py

@@ -1,14 +1,25 @@
 from __future__ import print_function
+
 import codecs
+import fnmatch
 import logging
+import os
+import uuid
 from collections import OrderedDict
 
 import yaml
+import yaml.constructor
 
-from esphomeyaml.core import ESPHomeYAMLError, HexInt, IPAddress
+from esphomeyaml import core
+from esphomeyaml.core import ESPHomeYAMLError, HexInt, IPAddress, Lambda, MACAddress, TimePeriod
 
 _LOGGER = logging.getLogger(__name__)
 
+# Mostly copied from Home Assistant because that code works fine and
+# let's not reinvent the wheel here
+
+SECRET_YAML = u'secrets.yaml'
+
 
 class NodeListClass(list):
     """Wrapper class to be able to add attributes on a list."""
@@ -22,7 +33,7 @@ class NodeStrClass(unicode):
     pass
 
 
-class SafeLineLoader(yaml.SafeLoader):
+class SafeLineLoader(yaml.SafeLoader):  # pylint: disable=too-many-ancestors
     """Loader class that keeps track of line numbers."""
 
     def compose_node(self, parent, index):
@@ -39,8 +50,9 @@ def load_yaml(fname):
         with codecs.open(fname, encoding='utf-8') as conf_file:
             return yaml.load(conf_file, Loader=SafeLineLoader) or OrderedDict()
     except yaml.YAMLError as exc:
-        _LOGGER.error(exc)
         raise ESPHomeYAMLError(exc)
+    except IOError as exc:
+        raise ESPHomeYAMLError(u"Error accessing file {}: {}".format(fname, exc))
     except UnicodeDecodeError as exc:
         _LOGGER.error(u"Unable to read file %s: %s", fname, exc)
         raise ESPHomeYAMLError(exc)
@@ -52,14 +64,83 @@ def dump(dict_):
         dict_, default_flow_style=False, allow_unicode=True)
 
 
+def custom_construct_pairs(loader, node):
+    pairs = []
+    for kv in node.value:
+        if isinstance(kv, yaml.ScalarNode):
+            obj = loader.construct_object(kv)
+            if not isinstance(obj, dict):
+                raise ESPHomeYAMLError(
+                    "Expected mapping for anchored include tag, got {}".format(type(obj)))
+            for key, value in obj.iteritems():
+                pairs.append((key, value))
+        else:
+            key_node, value_node = kv
+            key = loader.construct_object(key_node)
+            value = loader.construct_object(value_node)
+            pairs.append((key, value))
+
+    return pairs
+
+
+def custom_flatten_mapping(loader, node):
+    pre_merge = []
+    post_merge = []
+    index = 0
+    while index < len(node.value):
+        if isinstance(node.value[index], yaml.ScalarNode):
+            index += 1
+            continue
+
+        key_node, value_node = node.value[index]
+        if key_node.tag == u'tag:yaml.org,2002:merge':
+            del node.value[index]
+
+            if isinstance(value_node, yaml.MappingNode):
+                custom_flatten_mapping(loader, value_node)
+                node.value = node.value[:index] + value_node.value + node.value[index:]
+            elif isinstance(value_node, yaml.SequenceNode):
+                submerge = []
+                for subnode in value_node.value:
+                    if not isinstance(subnode, yaml.MappingNode):
+                        raise yaml.constructor.ConstructorError(
+                            "while constructing a mapping", node.start_mark,
+                            "expected a mapping for merging, but found %{}".format(subnode.id),
+                            subnode.start_mark)
+                    custom_flatten_mapping(loader, subnode)
+                    submerge.append(subnode.value)
+                # submerge.reverse()
+                node.value = node.value[:index] + submerge + node.value[index:]
+            elif isinstance(value_node, yaml.ScalarNode):
+                node.value = node.value[:index] + [value_node] + node.value[index:]
+                # post_merge.append(value_node)
+            else:
+                raise yaml.constructor.ConstructorError(
+                    "while constructing a mapping", node.start_mark,
+                    "expected a mapping or list of mappings for merging, "
+                    "but found {}".format(value_node.id), value_node.start_mark)
+        elif key_node.tag == u'tag:yaml.org,2002:value':
+            key_node.tag = u'tag:yaml.org,2002:str'
+            index += 1
+        else:
+            index += 1
+    if pre_merge:
+        node.value = pre_merge + node.value
+    if post_merge:
+        node.value = node.value + post_merge
+
+
 def _ordered_dict(loader, node):
     """Load YAML mappings into an ordered dictionary to preserve key order."""
-    loader.flatten_mapping(node)
-    nodes = loader.construct_pairs(node)
+    custom_flatten_mapping(loader, node)
+    nodes = custom_construct_pairs(loader, node)
 
     seen = {}
-    for (key, _), (child_node, _) in zip(nodes, node.value):
-        line = child_node.start_mark.line
+    for (key, _), nv in zip(nodes, node.value):
+        if isinstance(nv, yaml.ScalarNode):
+            line = nv.start_mark.line
+        else:
+            line = nv[0].start_mark.line
 
         try:
             hash(key)
@@ -72,9 +153,8 @@ def _ordered_dict(loader, node):
 
         if key in seen:
             fname = getattr(loader.stream, 'name', '')
-            _LOGGER.error(
-                u'YAML file %s contains duplicate key "%s". '
-                u'Check lines %d and %d.', fname, key, seen[key], line)
+            raise ESPHomeYAMLError(u'YAML file {} contains duplicate key "{}". '
+                                   u'Check lines {} and {}.'.format(fname, key, seen[key], line))
         seen[key] = line
 
     return _add_reference(OrderedDict(nodes), loader, node)
@@ -97,8 +177,112 @@ def _add_reference(obj, loader, node):
     return obj
 
 
+def _env_var_yaml(_, node):
+    """Load environment variables and embed it into the configuration YAML."""
+    args = node.value.split()
+
+    # Check for a default value
+    if len(args) > 1:
+        return os.getenv(args[0], u' '.join(args[1:]))
+    elif args[0] in os.environ:
+        return os.environ[args[0]]
+    raise ESPHomeYAMLError(u"Environment variable {} not defined.".format(node.value))
+
+
+def _include_yaml(loader, node):
+    """Load another YAML file and embeds it using the !include tag.
+
+    Example:
+        device_tracker: !include device_tracker.yaml
+    """
+    fname = os.path.join(os.path.dirname(loader.name), node.value)
+    return _add_reference(load_yaml(fname), loader, node)
+
+
+def _is_file_valid(name):
+    """Decide if a file is valid."""
+    return not name.startswith(u'.')
+
+
+def _find_files(directory, pattern):
+    """Recursively load files in a directory."""
+    for root, dirs, files in os.walk(directory, topdown=True):
+        dirs[:] = [d for d in dirs if _is_file_valid(d)]
+        for basename in files:
+            if _is_file_valid(basename) and fnmatch.fnmatch(basename, pattern):
+                filename = os.path.join(root, basename)
+                yield filename
+
+
+def _include_dir_named_yaml(loader, node):
+    """Load multiple files from directory as a dictionary."""
+    mapping = OrderedDict()  # type: OrderedDict
+    loc = os.path.join(os.path.dirname(loader.name), node.value)
+    for fname in _find_files(loc, '*.yaml'):
+        filename = os.path.splitext(os.path.basename(fname))[0]
+        mapping[filename] = load_yaml(fname)
+    return _add_reference(mapping, loader, node)
+
+
+def _include_dir_merge_named_yaml(loader, node):
+    """Load multiple files from directory as a merged dictionary."""
+    mapping = OrderedDict()  # type: OrderedDict
+    loc = os.path.join(os.path.dirname(loader.name), node.value)
+    for fname in _find_files(loc, '*.yaml'):
+        if os.path.basename(fname) == SECRET_YAML:
+            continue
+        loaded_yaml = load_yaml(fname)
+        if isinstance(loaded_yaml, dict):
+            mapping.update(loaded_yaml)
+    return _add_reference(mapping, loader, node)
+
+
+def _include_dir_list_yaml(loader, node):
+    """Load multiple files from directory as a list."""
+    loc = os.path.join(os.path.dirname(loader.name), node.value)
+    return [load_yaml(f) for f in _find_files(loc, '*.yaml')
+            if os.path.basename(f) != SECRET_YAML]
+
+
+def _include_dir_merge_list_yaml(loader, node):
+    """Load multiple files from directory as a merged list."""
+    path = os.path.join(os.path.dirname(loader.name), node.value)
+    merged_list = []
+    for fname in _find_files(path, '*.yaml'):
+        if os.path.basename(fname) == SECRET_YAML:
+            continue
+        loaded_yaml = load_yaml(fname)
+        if isinstance(loaded_yaml, list):
+            merged_list.extend(loaded_yaml)
+    return _add_reference(merged_list, loader, node)
+
+
+# pylint: disable=protected-access
+def _secret_yaml(loader, node):
+    """Load secrets and embed it into the configuration YAML."""
+    secret_path = os.path.join(os.path.dirname(loader.name), SECRET_YAML)
+    secrets = load_yaml(secret_path)
+    if node.value not in secrets:
+        raise ESPHomeYAMLError(u"Secret {} not defined".format(node.value))
+    return secrets[node.value]
+
+
+def _lambda(loader, node):
+    return Lambda(unicode(node.value))
+
+
 yaml.SafeLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _ordered_dict)
 yaml.SafeLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG, _construct_seq)
+yaml.SafeLoader.add_constructor('!env_var', _env_var_yaml)
+yaml.SafeLoader.add_constructor('!secret', _secret_yaml)
+yaml.SafeLoader.add_constructor('!include', _include_yaml)
+yaml.SafeLoader.add_constructor('!include_dir_list', _include_dir_list_yaml)
+yaml.SafeLoader.add_constructor('!include_dir_merge_list',
+                                _include_dir_merge_list_yaml)
+yaml.SafeLoader.add_constructor('!include_dir_named', _include_dir_named_yaml)
+yaml.SafeLoader.add_constructor('!include_dir_merge_named',
+                                _include_dir_merge_named_yaml)
+yaml.SafeLoader.add_constructor('!lambda', _lambda)
 
 
 # From: https://gist.github.com/miracle2k/3184458
@@ -129,21 +313,53 @@ def represent_odict(dump, tag, mapping, flow_style=None):
     return node
 
 
-def unicode_representer(dumper, uni):
+def unicode_representer(_, uni):
     node = yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=uni)
     return node
 
 
-def hex_int_representer(dumper, data):
+def hex_int_representer(_, data):
     node = yaml.ScalarNode(tag=u'tag:yaml.org,2002:int', value=str(data))
     return node
 
 
-def ipaddress_representer(dumper, data):
+def stringify_representer(_, data):
     node = yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=str(data))
     return node
 
 
+TIME_PERIOD_UNIT_MAP = {
+    'microseconds': 'us',
+    'milliseconds': 'ms',
+    'seconds': 's',
+    'minutes': 'min',
+    'hours': 'h',
+    'days': 'd',
+}
+
+
+def represent_time_period(dumper, data):
+    dictionary = data.as_dict()
+    if len(dictionary) == 1:
+        unit, value = dictionary.popitem()
+        out = '{}{}'.format(value, TIME_PERIOD_UNIT_MAP[unit])
+        return yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=out)
+    return represent_odict(dumper, 'tag:yaml.org,2002:map', dictionary)
+
+
+def represent_lambda(_, data):
+    node = yaml.ScalarNode(tag='!lambda', value=data.value, style='>')
+    return node
+
+
+def represent_id(_, data):
+    return yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=data.id)
+
+
+def represent_uuid(_, data):
+    return yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=str(data))
+
+
 yaml.SafeDumper.add_representer(
     OrderedDict,
     lambda dumper, value:
@@ -158,4 +374,9 @@ yaml.SafeDumper.add_representer(
 
 yaml.SafeDumper.add_representer(unicode, unicode_representer)
 yaml.SafeDumper.add_representer(HexInt, hex_int_representer)
-yaml.SafeDumper.add_representer(IPAddress, ipaddress_representer)
+yaml.SafeDumper.add_representer(IPAddress, stringify_representer)
+yaml.SafeDumper.add_representer(MACAddress, stringify_representer)
+yaml.SafeDumper.add_multi_representer(TimePeriod, represent_time_period)
+yaml.SafeDumper.add_multi_representer(Lambda, represent_lambda)
+yaml.SafeDumper.add_multi_representer(core.ID, represent_id)
+yaml.SafeDumper.add_multi_representer(uuid.UUID, represent_uuid)

examples/README.md

@@ -1,3 +0,0 @@
-# Examples
-
-This directory contains some of the ESP32/ESP8266 nodes I use at my home.

examples/cabinet.yaml

@@ -1,127 +0,0 @@
-esphomeyaml:
-  name: cabinet
-  platform: ESP32
-  board: nodemcu-32s
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.203
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: cabinet
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-power_supply:
-  - id: 'atx'
-    pin:
-      number: 13
-      inverted: true
-
-i2c:
-  sda: 14
-  scl: 27
-  frequency: 400000
-
-pca9685:
-  - id: 'pca9685'
-    frequency: 500
-
-output:
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'cabinet1_red'
-    channel: 14
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'cabinet1_green'
-    channel: 15
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'cabinet1_blue'
-    channel: 13
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'cabinet2_red'
-    channel: 11
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'cabinet2_green'
-    channel: 12
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'cabinet2_blue'
-    channel: 10
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'room_red'
-    channel: 8
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'room_green'
-    channel: 9
-    power_supply: 'atx'
-  - platform: pca9685
-    pca9685_id: 'pca9685'
-    id: 'room_blue'
-    channel: 7
-    power_supply: 'atx'
-
-light:
-  - platform: rgb
-    name: 'Cabinet Light 1'
-    red: 'cabinet1_red'
-    green: 'cabinet1_green'
-    blue: 'cabinet1_blue'
-  - platform: rgb
-    name: 'Cabinet Light 2'
-    red: 'cabinet2_red'
-    green: 'cabinet2_green'
-    blue: 'cabinet2_blue'
-  - platform: rgb
-    name: 'Room Light'
-    red: 'room_red'
-    green: 'room_green'
-    blue: 'room_blue'
-
-sensor:
-  - platform: dht
-    pin: 23
-    temperature:
-      name: 'Cabinet Temperature'
-    humidity:
-      name: 'Cabinet Humidity'
-    model: DHT22
-
-binary_sensor:
-  - platform: gpio
-    pin: 25
-    name: 'Cabinet Motion'
-    device_class: motion
-  # Simple binary sensor that uses last will and birth messages to show
-  # node state
-  - platform: status
-    name: "Cabinet Status"
-
-switch:
-  # Simple switch that restarts the ESP32
-  - platform: restart
-    name: "Cabinet Restart"

examples/dachboden.yaml

@@ -1,57 +0,0 @@
-esphomeyaml:
-  name: dachboden
-  platform: ESP8266
-  board: nodemcuv2
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.212
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: dachboden
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-
-dallas:
-  id: 'dallas'
-  pin: D1
-
-sensor:
-  - platform: dht
-    pin: D3
-    temperature:
-      name: 'Dachboden Temperatur'
-    humidity:
-      name: 'Dachboden Luftfeuchtigkeit'
-    model: DHT22
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x01031663650aff28
-    name: "Dachboden Solar Süd Vorlauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x2b0416638fe6ff28
-    name: "Dachboden Solar Süd Rücklauf"
-  - platform: adc
-    pin: A0
-    name: "Dachboden Helligkeit"
-
-binary_sensor:
-  - platform: status
-    name: "Dachboden Status"
-
-switch:
-  - platform: restart
-    name: "Dachboden Neustart"

examples/heatpump.yaml

@@ -1,117 +0,0 @@
-esphomeyaml:
-  name: heatpump
-  platform: ESP32
-  board: nodemcu-32s
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.204
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: heatpump
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-dallas:
-  id: 'dallas'
-  pin: 15
-
-sensor:
-  - platform: dht
-    pin: 0
-    temperature:
-      name: 'Outside Temperature'
-    humidity:
-      name: 'Outside Humidity'
-    model: DHT22
-  - platform: pulse_counter
-    pin: 12
-    unit_of_measurement: 'kW'
-    name: 'Stromverbrauch Wintergarten'
-    update_interval: 30s
-    expire_after: 60s
-    filters:
-      - multiply: 0.06
-  - platform: pulse_counter
-    pin: 13
-    unit_of_measurement: 'kW'
-    name: 'Stromverbrauch Wärmepumpe'
-    update_interval: 30s
-    expire_after: 60s
-    filters:
-      - multiply: 0.06
-  - platform: pulse_counter
-    pin: 14
-    unit_of_measurement: 'kW'
-    name: 'Stromverbrauch Gesamt'
-    update_interval: 30s
-    expire_after: 60s
-    filters:
-      - multiply: 0.06
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0xfe0000031f1eaf28
-    name: "Boiler Temperatur Oben"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0xba0000031f0e5228
-    name: "Boiler Temperatur Unten"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0xa40000031f055028
-    name: "Boiler Temperatur Mitte"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x790000031ee1dc28
-    name: "Heizung Rücklauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0xdd0000031efb0428
-    name: "Ölheizung Vorlauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x710000031f0e7e28
-    name: "Boiler Solar Rücklauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x92041703081aff28
-    name: "Boiler Solar Vorlauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x2c04173159f4ff28
-    name: "Heizung Vorlauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0xd10417315babff28
-    name: "Wärmepumpe Vorlauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x6c0517024a17ff28
-    name: "Boiler Heizung Vorlauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x7d04173139eeff28
-    name: "Wärmepumpe Rücklauf"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x3204166398a5ff28
-    name: "Wärmepumpe Verdampfer"
-
-binary_sensor:
-  - platform: status
-    name: "Heizung Status"
-
-switch:
-  - platform: restart
-    name: "Heizung Neustart"

examples/kuche.yaml

@@ -1,60 +0,0 @@
-esphomeyaml:
-  name: kuche
-  platform: ESP8266
-  board: nodemcuv2
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.211
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: kuche
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-
-dallas:
-  id: 'dallas'
-  pin: D1
-
-sensor:
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x69041662d7f1ff28
-    name: "Küche Raumtemperatur"
-  - platform: dallas
-    dallas_id: 'dallas'
-    address: 0x800416636bebff28
-    name: "Küche Heizkörpertemperatur"
-  - platform: adc
-    pin: A0
-    name: "Küche Helligkeit"
-
-output:
-  - platform: gpio
-    pin: D2
-    id: 'ventilator'
-
-fan:
-  - platform: binary
-    output: 'ventilator'
-    name: 'Küche Heizkörper Ventilator'
-
-binary_sensor:
-  - platform: status
-    name: "Küche Status"
-
-switch:
-  - platform: restart
-    name: "Küche Neustart"

examples/lebensmittelkeller.yaml

@@ -1,58 +0,0 @@
-esphomeyaml:
-  name: lebensmittelkeller
-  platform: ESP8266
-  board: nodemcuv2
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.209
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: lebensmittelkeller
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-sensor:
-  - platform: dht
-    pin: D3
-    temperature:
-      name: 'Lebensmittelkeller Temperatur'
-    humidity:
-      name: 'Lebensmittelkeller Feuchtigkeit'
-    model: DHT22
-  - platform: adc
-    pin: A0
-    name: "Lebensmittelkeller Helligkeit"
-
-output:
-  - platform: gpio
-    pin: D4
-    id: 'ventilator'
-
-fan:
-  - platform: binary
-    output: 'ventilator'
-    name: 'Lebensmittelkeller Ventilator'
-
-switch:
-  - platform: gpio
-    pin: D2
-    name: 'Lebensmittelkeller Entfeuchter'
-    icon: 'mdi:water-off'
-  - platform: restart
-    name: "Lebensmittelkeller Neustart"
-
-binary_sensor:
-  - platform: status
-    name: "Lebensmittelkeller Status"

examples/livingroom.yaml

@@ -1,344 +0,0 @@
-esphomeyaml:
-  name: livingroom
-  platform: ESP32
-  board: nodemcu-32s
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.201
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: livingroom
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-output:
-  - platform: ledc
-    id: 'fan_float'
-    frequency: 50000
-    pin: 22
-    bit_depth: 8
-
-dallas:
-  pin: 23
-  id: dallas
-
-sensor:
-  - platform: dallas
-    dallas_id: dallas
-    address: 0x1c0000031edd2a28
-    name: "Wohnzimmer Raumtemperatur"
-    filters:
-      - sliding_window_moving_average:
-          window_size: 15
-          send_every: 15
-      - filter_out: 85
-  - platform: dallas
-    dallas_id: dallas
-    address: 0x7a0315a8371eff28
-    name: "Wohnzimmer Heizkörpertemperatur"
-    update_interval: 30s
-    filters:
-      - sliding_window_moving_average:
-          window_size: 15
-          send_every: 15
-      - filter_out: 85
-
-fan:
-  - platform: speed
-    output: 'fan_float'
-    name: 'Wohnzimmer Heizkörper Ventilator'
-
-binary_sensor:
-  - platform: status
-    name: "Wohnzimmer Status"
-
-ir_transmitter:
-  pin: 32
-  id: 'ir'
-
-switch:
-  - platform: restart
-    name: "Wohnzimmer Neustart"
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV On"
-    panasonic:
-      address: 0x4004
-      command: 0x100BCBD
-    repeat: 25
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Off"
-    panasonic:
-      address: 0x4004
-      command: 0x100BCBD
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV SD Card"
-    panasonic:
-      address: 0x4004
-      command: 0x190D544
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Input TV"
-    panasonic:
-      address: 0x4004
-      command: 0x1400C4D
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Input AV"
-    panasonic:
-      address: 0x4004
-      command: 0x100A0A1
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Menu"
-    panasonic:
-      address: 0x4004
-      command: 0x1004A4B
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Aspect Ratio"
-    panasonic:
-      address: 0x4004
-      command: 0x1207B5A
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Viera Cast"
-    panasonic:
-      address: 0x4004
-      command: 0x190C958
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Direct TV REC"
-    panasonic:
-      address: 0x4004
-      command: 0x1909100
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Info"
-    panasonic:
-      address: 0x4004
-      command: 0x1009C9D
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Exit"
-    panasonic:
-      address: 0x4004
-      command: 0x100CBCA
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Viera Link"
-    panasonic:
-      address: 0x4004
-      command: 0x1908D1C
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Viera Tools"
-    panasonic:
-      address: 0x4004
-      command: 0x100F7F6
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Guide"
-    panasonic:
-      address: 0x4004
-      command: 0x190E170
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Up"
-    panasonic:
-      address: 0x4004
-      command: 0x1005253
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Left"
-    panasonic:
-      address: 0x4004
-      command: 0x1007273
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV OK"
-    panasonic:
-      address: 0x4004
-      command: 0x1009293
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Right"
-    panasonic:
-      address: 0x4004
-      command: 0x100F2F3
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Down"
-    panasonic:
-      address: 0x4004
-      command: 0x100D2D3
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Option"
-    panasonic:
-      address: 0x4004
-      command: 0x190E574
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Back"
-    panasonic:
-      address: 0x4004
-      command: 0x1002B2A
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Red"
-    panasonic:
-      address: 0x4004
-      command: 0x1000E0F
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Green"
-    panasonic:
-      address: 0x4004
-      command: 0x1000E0F  # TODO: FIXME
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Yellow"
-    panasonic:
-      address: 0x4004
-      command: 0x1004E4F
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Blue"
-    panasonic:
-      address: 0x4004
-      command: 0x100CECF
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Text"
-    panasonic:
-      address: 0x4004
-      command: 0x180C041
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Subtitle"
-    panasonic:
-      address: 0x4004
-      command: 0x180A021
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Index"
-    panasonic:
-      address: 0x4004
-      command: 0x1801091
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Hold"
-    panasonic:
-      address: 0x4004
-      command: 0x1809011
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 1"
-    panasonic:
-      address: 0x4004
-      command: 0x1000809
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 2"
-    panasonic:
-      address: 0x4004
-      command: 0x1008889
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 3"
-    panasonic:
-      address: 0x4004
-      command: 0x1004849
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 4"
-    panasonic:
-      address: 0x4004
-      command: 0x100C8C9
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 5"
-    panasonic:
-      address: 0x4004
-      command: 0x1002829
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 6"
-    panasonic:
-      address: 0x4004
-      command: 0x100A8A9
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 7"
-    panasonic:
-      address: 0x4004
-      command: 0x1006869
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 8"
-    panasonic:
-      address: 0x4004
-      command: 0x100E8E9
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 9"
-    panasonic:
-      address: 0x4004
-      command: 0x1001819
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV 0"
-    panasonic:
-      address: 0x4004
-      command: 0x1009899
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Mute"
-    panasonic:
-      address: 0x4004
-      command: 0x1004C4D
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Last View"
-    panasonic:
-      address: 0x4004
-      command: 0x100ECED
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Volume Up"
-    panasonic:
-      address: 0x4004
-      command: 0x1000405
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Volume Down"
-    panasonic:
-      address: 0x4004
-      command: 0x1008485
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Program Up"
-    panasonic:
-      address: 0x4004
-      command: 0x1002C2D
-  - platform: ir_transmitter
-    ir_transmitter_id: 'ir'
-    name: "Panasonic TV Program Down"
-    panasonic:
-      address: 0x4004
-      command: 0x100ACAD

examples/terrasse.yaml

@@ -1,48 +0,0 @@
-esphomeyaml:
-  name: terrasse
-  platform: ESP32
-  board: nodemcu-32s
-
-logger:
-  level: verbose
-
-wifi:
-  ssid: '[SSID]'
-  password: '[PASSWORD]'
-  manual_ip:
-    static_ip: 192.168.178.205
-    gateway: 192.168.178.1
-    subnet: 255.255.255.0
-
-ota:
-
-mqtt:
-  broker: 192.168.178.84
-  username: terrasse
-  password: '[PASSWORD]'
-  # This is the default
-  discovery: true
-
-dallas:
-  pin: 25
-  id: dallas
-
-sensor:
-  - platform: pulse_counter
-    pin: 34
-    name: "Terrasse Wind"
-  - platform: pulse_counter
-    pin: 39
-    name: "Terrasse Regen"
-  - platform: dallas
-    dallas_id: dallas
-    index: 0
-    name: "Terrasse Temperatur"
-
-binary_sensor:
-  - platform: status
-    name: "Terrasse Status"
-
-switch:
-  - platform: restart
-    name: "Terrasse Neustart"

pylintrc

@@ -0,0 +1,26 @@
+[MASTER]
+reports=no
+
+disable=
+  missing-docstring,
+  fixme,
+  unused-argument,
+  global-statement,
+  too-few-public-methods,
+  too-many-locals,
+  too-many-ancestors,
+  too-many-branches,
+  too-many-statements,
+  too-many-arguments,
+  too-many-return-statements,
+  duplicate-code,
+  invalid-name,
+  cyclic-import,
+  redefined-builtin,
+  undefined-loop-variable,
+
+
+additional-builtins=
+  unicode,
+  long,
+  raw_input

repository.json

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

requirements.txt

@@ -1,5 +1,7 @@
-voluptuous==0.11.1
-platformio==3.5.2
-pyyaml==3.12
-paho-mqtt==1.3.1
-colorlog==3.1.2
+voluptuous>=0.11.1
+platformio>=3.5.3
+pyyaml>=3.12
+paho-mqtt>=1.3.1
+colorlog>=3.1.2
+tornado>=5.0.0
+esptool>=2.3.1

setup.cfg

@@ -1,2 +1,6 @@
 [metadata]
 description-file = README.md
+
+[flake8]
+max-line-length = 120
+builtins = unicode, long, raw_input

setup.py

@@ -23,10 +23,12 @@ DOWNLOAD_URL = '{}/archive/{}.zip'.format(GITHUB_URL, const.__version__)
 
 REQUIRES = [
     'voluptuous>=0.11.1',
-    'platformio>=3.5.2',
+    'platformio>=3.5.3',
     'pyyaml>=3.12',
     'paho-mqtt>=1.3.1',
     'colorlog>=3.1.2',
+    'tornado>=5.0.0',
+    'esptool>=2.3.1',
 ]
 
 CLASSIFIERS = [

tests/README.md

@@ -0,0 +1,11 @@
+# Tests for esphomeyaml
+
+This directory contains some tests for esphomeyaml.
+At the moment, all the tests only work by simply executing
+`esphomeyaml` over some YAML files that are made to test
+all of esphomeyaml's features.
+
+Of course this is all just very high-level and things like
+unit tests would be much better. So if you have time and know
+how to set up a unit testing framework for python, please do
+give it a try.

tests/test1.yaml

@@ -0,0 +1,1047 @@
+esphomeyaml:
+  name: test1
+  platform: ESP32
+  board: nodemcu-32s
+  # Use latest upstream esphomelib git version.
+  esphomelib_version: dev
+  # Use this for testing while developing:
+  # esphomelib_version:
+  #   local: ~/path/to/esphomelib
+  use_custom_code: false
+  on_boot:
+    priority: 150.0
+    then:
+      - lambda: >-
+          ESP_LOGD("main", "ON BOOT!");
+  on_shutdown:
+    then:
+      - lambda: >-
+          ESP_LOGD("main", "ON SHUTDOWN!");
+  on_loop:
+    then:
+      - lambda: >-
+          ESP_LOGV("main", "ON LOOP!");
+  build_path: build/test1
+
+wifi:
+  ssid: 'MySSID'
+  password: 'password1'
+  manual_ip:
+    static_ip: 192.168.178.230
+    gateway: 192.168.178.1
+    subnet: 255.255.255.0
+    dns1: 1.1.1.1
+    dns2: 1.2.2.1
+  hostname: myverylonghostname
+  domain: .local
+  reboot_timeout: 120s
+  power_save_mode: none
+
+mqtt:
+  broker: '192.168.178.84'
+  port: 1883
+  username: 'debug'
+  password: 'debug'
+  client_id: someclient
+  discovery: True
+  discovery_retain: False
+  discovery_prefix: discovery
+  topic_prefix: helloworld
+  log_topic:
+    topic: helloworld/hi
+    level: INFO
+  birth_message:
+  will_message:
+  shutdown_message:
+    topic: topic/to/send/to
+    payload: hi
+    qos: 2
+    retain: True
+  keepalive: 60s
+  reboot_timeout: 60s
+  on_message:
+    - topic: my/custom/topic
+      qos: 0
+      then:
+        - lambda: >-
+            ESP_LOGD("main", "Got message %s", x.c_str());
+    - topic: livingroom/ota_mode
+      then:
+      - deep_sleep.prevent: deep_sleep_1
+    - topic: livingroom/ota_mode
+      then:
+      - deep_sleep.enter: deep_sleep_1
+  on_json_message:
+    topic: the/topic
+    then:
+      - lambda: |-
+          int data = x["my_data"];
+          ESP_LOGD("main", "The data is: %d", data);
+      - light.turn_on:
+          id: living_room_lights
+          transition_length: !lambda |-
+            int length = 1000;
+            if (x.containsKey("length"))
+              length = x["length"];
+            return length;
+          effect: !lambda |-
+            const char *effect = "None";
+            if (x.containsKey("effect"))
+              effect = x["effect"];
+            return effect;
+
+i2c:
+  sda: 21
+  scl: 22
+  scan: True
+  frequency: 100kHz
+  setup_priority: -100
+
+spi:
+  clk_pin: GPIO21
+  mosi_pin: GPIO22
+  miso_pin: GPIO23
+
+uart:
+  tx_pin: GPIO22
+  rx_pin: GPIO23
+  baud_rate: 115200
+
+ota:
+  safe_mode: True
+  password: 'superlongpasswordthatnoonewillknow'
+  port: 3286
+
+logger:
+  baud_rate: 0
+  level: VERBOSE
+  logs:
+    mqtt.component: DEBUG
+    mqtt.client: ERROR
+
+web_server:
+  port: 8080
+  css_url: https://esphomelib.com/_static/webserver-v1.min.css
+  js_url: https://esphomelib.com/_static/webserver-v1.min.js
+
+power_supply:
+  id: 'atx_power_supply'
+  enable_time: 20ms
+  keep_on_time: 10s
+  pin:
+    number: 13
+    inverted: true
+
+deep_sleep:
+  run_duration: 20s
+  run_cycles: 500
+  sleep_duration: 50s
+  wakeup_pin: GPIO39
+  wakeup_pin_mode: INVERT_WAKEUP
+  id: deep_sleep_1
+
+ads1115:
+  address: 0x48
+
+dallas:
+  pin: GPIO23
+
+sensor:
+  - platform: adc
+    pin: A0
+    name: "Living Room Brightness"
+    update_interval: '1:01'
+    attenuation: 2.5db
+    unit_of_measurement: "°C"
+    icon: "mdi:water-percent"
+    accuracy_decimals: 5
+    expire_after: 120s
+    setup_priority: -100
+    filters:
+      - offset: 2.0
+      - multiply: 1.2
+      - filter_out: 42.0
+      - filter_nan:
+      - sliding_window_moving_average:
+          window_size: 15
+          send_every: 15
+          send_first_at: 15
+      - exponential_moving_average:
+          alpha: 0.1
+          send_every: 15
+      - throttle: 1s
+      - heartbeat: 5s
+      - debounce: 0.1s
+      - delta: 5.0
+      - unique:
+      - or:
+        - throttle: 1s
+        - delta: 5.0
+      - lambda: return x * (9.0/5.0) + 32.0;
+    on_value:
+      then:
+        - lambda: >-
+            ESP_LOGD("main", "Got value %f", x);
+            id(my_sensor).publish_state(42.0);
+            ESP_LOGI("main", "Value of my sensor: %f", id(my_sensor).state);
+            ESP_LOGI("main", "Raw Value of my sensor: %f", id(my_sensor).state);
+    on_value_range:
+      above: 5
+      below: 10
+      then:
+        - lambda: >-
+            ESP_LOGD("main", "Got value range %f", x);
+    on_raw_value:
+      - lambda: >-
+          ESP_LOGD("main", "Got raw value %f", x);
+      - logger.log:
+          level: DEBUG
+          format: "Got raw value %f"
+          args: ['x']
+      - logger.log: "Got raw value NAN"
+      - mqtt.publish:
+          topic: some/topic
+          payload: Hello
+          qos: 2
+          retain: True
+  - platform: ads1115
+    multiplexer: 'A0_A1'
+    gain: 1.024
+    id: my_sensor
+    filters:
+    state_topic: hi/me
+    retain: false
+    availability:
+  - platform: bh1750
+    name: "Living Room Brightness 3"
+    internal: true
+    address: 0x23
+    resolution: 1.0
+    update_interval: 30s
+    retain: False
+    availability:
+    state_topic: livingroom/custom_state_topic
+  - platform: bme280
+    temperature:
+      name: "Outside Temperature"
+      oversampling: 16x
+    pressure:
+      name: "Outside Pressure"
+      oversampling: none
+    humidity:
+      name: "Outside Humidity"
+      oversampling: 8x
+    address: 0x77
+    iir_filter: 16x
+    update_interval: 15s
+  - platform: bme680
+    temperature:
+      name: "Outside Temperature"
+      oversampling: 16x
+    pressure:
+      name: "Outside Pressure"
+    humidity:
+      name: "Outside Humidity"
+    gas_resistance:
+      name: "Outside Gas Sensor"
+    address: 0x77
+    heater:
+      temperature: 320
+      duration: 150ms
+    update_interval: 15s
+  - platform: bmp085
+    temperature:
+      name: "Outside Temperature"
+    pressure:
+      name: "Outside Pressure"
+      filters:
+        - lambda: >-
+            return x / powf(1.0 - (x / 44330.0), 5.255);
+    update_interval: 15s
+  - platform: bmp280
+    temperature:
+      name: "Outside Temperature"
+      oversampling: 16x
+    pressure:
+      name: "Outside Pressure"
+    address: 0x77
+    update_interval: 15s
+    iir_filter: 16x
+  - platform: dallas
+    address: 0x1C0000031EDD2A28
+    name: "Living Room Temperature"
+    resolution: 9
+  - platform: dallas
+    index: 1
+    name: "Living Room Temperature 2"
+  - platform: dht
+    pin: GPIO26
+    temperature:
+      name: "Living Room Temperature 3"
+    humidity:
+      name: "Living Room Humidity 3"
+    model: AM2302
+    update_interval: 15s
+  - platform: dht12
+    temperature:
+      name: "Living Room Temperature 4"
+    humidity:
+      name: "Living Room Humidity 4"
+    update_interval: 15s
+  - platform: duty_cycle
+    pin: GPIO25
+    name: Duty Cycle Sensor
+  - platform: esp32_hall
+    name: "ESP32 Hall Sensor"
+    update_interval: 15s
+  - platform: hdc1080
+    temperature:
+      name: "Living Room Temperature 5"
+    humidity:
+      name: "Living Room Pressure 5"
+    update_interval: 15s
+  - platform: hlw8012
+    sel_pin: 5
+    cf_pin: 14
+    cf1_pin: 13
+    current:
+      name: "HLW8012 Current"
+    voltage:
+      name: "HLW8012 Voltage"
+    power:
+      name: "HLW8012 Power"
+      id: hlw8012_power
+    update_interval: 15s
+    current_resistor: 0.001 ohm
+    voltage_divider: 2351
+    change_mode_every: 16
+  - platform: total_daily_energy
+    power_id: hlw8012_power
+    name: "HLW8012 Total Daily Energy"
+  - platform: hmc5883l
+    address: 0x68
+    field_strength_x:
+      name: "HMC5883L Field Strength X"
+    field_strength_y:
+      name: "HMC5883L Field Strength Y"
+    field_strength_z:
+      name: "HMC5883L Field Strength Z"
+    heading:
+      name: "HMC5883L Heading"
+    range: 130uT
+    update_interval: 15s
+  - platform: hx711
+    name: "HX711 Value"
+    dout_pin: GPIO23
+    clk_pin: GPIO24
+    gain: 128
+    update_interval: 15s
+  - platform: ina219
+    address: 0x40
+    shunt_resistance: 0.1 ohm
+    current:
+      name: "INA219 Current"
+    power:
+      name: "INA219 Power"
+    bus_voltage:
+      name: "INA219 Bus Voltage"
+    shunt_voltage:
+      name: "INA219 Shunt Voltage"
+    max_voltage: 32.0V
+    max_current: 3.2A
+    update_interval: 15s
+  - platform: ina3221
+    address: 0x40
+    channel_1:
+      shunt_resistance: 0.1 ohm
+      current:
+        name: "INA3221 Channel 1 Current"
+      power:
+        name: "INA3221 Channel 1 Power"
+      bus_voltage:
+        name: "INA3221 Channel 1 Bus Voltage"
+      shunt_voltage:
+        name: "INA3221 Channel 1 Shunt Voltage"
+    update_interval: 15s
+  - platform: htu21d
+    temperature:
+      name: "Living Room Temperature 6"
+    humidity:
+      name: "Living Room Humidity 6"
+    update_interval: 15s
+  - platform: max6675
+    name: "Living Room Temperature"
+    cs_pin: GPIO23
+    update_interval: 15s
+  - platform: mhz19
+    co2:
+      name: "MH-Z19 CO2 Value"
+    temperature:
+      name: "MH-Z19 Temperature"
+    update_interval: 15s
+  - platform: mpu6050
+    address: 0x68
+    accel_x:
+      name: "MPU6050 Accel X"
+    accel_y:
+      name: "MPU6050 Accel Y"
+    accel_z:
+      name: "MPU6050 Accel z"
+    gyro_x:
+      name: "MPU6050 Gyro X"
+    gyro_y:
+      name: "MPU6050 Gyro Y"
+    gyro_z:
+      name: "MPU6050 Gyro z"
+    temperature:
+      name: "MPU6050 Temperature"
+  - platform: ms5611
+    temperature:
+      name: "Outside Temperature"
+    pressure:
+      name: "Outside Pressure"
+    address: 0x77
+    update_interval: 15s
+  - platform: pulse_counter
+    name: "Pulse Counter"
+    pin: GPIO12
+    count_mode:
+      rising_edge: INCREMENT
+      falling_edge: DECREMENT
+    internal_filter: 13us
+    update_interval: 15s
+  - platform: rotary_encoder
+    name: "Rotary Encoder"
+    pin_a: GPIO23
+    pin_b: GPIO24
+    pin_reset: GPIO25
+    filters:
+      - or:
+        - debounce: 0.1s
+        - delta: 10
+  - platform: sht3xd
+    temperature:
+      name: "Living Room Temperature 8"
+    humidity:
+      name: "Living Room Humidity 8"
+    address: 0x44
+    update_interval: 15s
+  - platform: template
+    name: "Template Sensor"
+    lambda: >-
+      if (id(ultrasonic_sensor1).state > 1) {
+        return 42.0;
+      } else {
+        return {};
+      }
+    update_interval: 15s
+  - platform: tsl2561
+    name: "TSL2561 Ambient Light"
+    address: 0x39
+    update_interval: 15s
+    is_cs_package: true
+    integration_time: 402ms
+    gain: 16x
+  - platform: ultrasonic
+    trigger_pin: GPIO24
+    echo_pin:
+      number: GPIO23
+      inverted: true
+    name: "Ultrasonic Sensor"
+    timeout_meter: 5.5
+    id: ultrasonic_sensor1
+  - platform: uptime
+    name: Uptime Sensor
+  - platform: wifi_signal
+    name: "WiFi Signal Sensor"
+    update_interval: 15s
+
+
+esp32_touch:
+  setup_mode: False
+  iir_filter: 10ms
+  sleep_duration: 27ms
+  measurement_duration: 8ms
+  low_voltage_reference: 0.5V
+  high_voltage_reference: 2.7V
+  voltage_attenuation: 1.5V
+
+binary_sensor:
+  - platform: gpio
+    pin: GPIO9
+    name: "Living Room Window"
+    device_class: window
+    filters:
+      - invert:
+      - delayed_on: 40ms
+      - delayed_off: 40ms
+      - heartbeat: 1s
+    on_press:
+      then:
+        - lambda: >-
+            ESP_LOGD("main", "Pressed");
+    on_release:
+      then:
+        - lambda: >-
+            ESP_LOGD("main", "Released");
+    on_click:
+      - min_length: 50ms
+        max_length: 350ms
+        then:
+          - lambda: >-
+              ESP_LOGD("main", "Clicked");
+      - then:
+          - lambda: >-
+              ESP_LOGD("main", "Clicked");
+    on_double_click:
+      - min_length: 50ms
+        max_length: 350ms
+        then:
+         - lambda: >-
+             ESP_LOGD("main", "Double Clicked");
+      - then:
+         - lambda: >-
+             ESP_LOGD("main", "Double Clicked");
+    on_multi_click:
+    - timing:
+      - ON for at most 1s
+      - OFF for at most 1s
+      - ON for at most 1s
+      - OFF for at least 0.2s
+      then:
+      - logger.log:
+          format: "Multi Clicked TWO"
+          level: warn
+    - timing:
+      - OFF for 1s to 2s
+      - ON for 1s to 2s
+      - OFF for at least 0.5s
+      then:
+      - logger.log:
+          format: "Multi Clicked LONG SINGLE"
+          level: warn
+    - timing:
+      - ON for at most 1s
+      - OFF for at least 0.5s
+      then:
+      - logger.log:
+          format: "Multi Clicked SINGLE"
+          level: warn
+    id: binary_sensor1
+  - platform: status
+    name: "Living Room Status"
+  - platform: esp32_touch
+    name: "ESP32 Touch Pad GPIO27"
+    pin: GPIO27
+    threshold: 1000
+  - platform: nextion
+    page_id: 0
+    component_id: 2
+    name: "Nextion Component 2 Touch"
+  - platform: template
+    name: "Garage Door Open"
+    lambda: >-
+      if (isnan(id(my_sensor).state)) {
+        // isnan checks if the ultrasonic sensor echo
+        // has timed out, resulting in a NaN (not a number) state
+        // in that case, return {} to indicate that we don't know.
+        return {};
+      } else if (id(my_sensor).state > 30) {
+        // Garage Door is open.
+        return true;
+      } else {
+        // Garage Door is closed.
+        return false;
+      }
+  - platform: pn532
+    uid: 74-10-37-94
+    name: "PN532 NFC Tag"
+  - platform: rdm6300
+    uid: 7616525
+    name: "RDM6300 NFC Tag"
+  - platform: gpio
+    name: "PCF binary sensor"
+    pin:
+      pcf8574: pcf8574_hub
+      number: 1
+      mode: INPUT
+      inverted: True
+
+pca9685:
+  frequency: 500
+  address: 0x0
+
+my9231:
+  data_pin: GPIO12
+  clock_pin: GPIO14
+  num_channels: 6
+  num_chips: 2
+  bit_depth: 16
+
+output:
+  - platform: gpio
+    pin: GPIO26
+    id: gpio_26
+    power_supply: atx_power_supply
+    inverted: False
+  - platform: ledc
+    pin: 19
+    id: gpio_19
+    frequency: 1500Hz
+    bit_depth: 8
+    channel: 14
+    max_power: 0.5
+  - platform: pca9685
+    id: pca_0
+    channel: 0
+  - platform: pca9685
+    id: pca_1
+    channel: 1
+  - platform: pca9685
+    id: pca_2
+    channel: 2
+  - platform: pca9685
+    id: pca_3
+    channel: 3
+  - platform: pca9685
+    id: pca_4
+    channel: 4
+  - platform: pca9685
+    id: pca_5
+    channel: 5
+  - platform: pca9685
+    id: pca_6
+    channel: 6
+  - platform: pca9685
+    id: pca_7
+    channel: 7
+  - platform: gpio
+    id: id2
+    pin:
+      pcf8574: pcf8574_hub
+      number: 0
+      mode: OUTPUT
+      inverted: False
+  - platform: my9231
+    id: my_0
+    channel: 0
+  - platform: my9231
+    id: my_1
+    channel: 1
+  - platform: my9231
+    id: my_2
+    channel: 2
+  - platform: my9231
+    id: my_3
+    channel: 3
+  - platform: my9231
+    id: my_4
+    channel: 4
+  - platform: my9231
+    id: my_5
+    channel: 5
+
+light:
+  - platform: binary
+    name: "Desk Lamp"
+    output: gpio_26
+    effects:
+      - strobe:
+      - strobe:
+          name: "My Strobe"
+          colors:
+            - state: True
+              duration: 250ms
+            - state: False
+              duration: 250ms
+  - platform: monochromatic
+    name: "Kitchen Lights"
+    id: kitchen
+    output: gpio_19
+    gamma_correct: 2.8
+    default_transition_length: 2s
+    effects:
+      - strobe:
+      - flicker:
+      - flicker:
+          name: "My Flicker"
+          alpha: 98%
+          intensity: 1.5%
+      - lambda:
+          name: My Custom Effect
+          update_interval: 1s
+          lambda: |-
+            static int state = 0;
+            state += 1;
+            if (state == 4)
+              state = 0;
+  - platform: rgb
+    name: "Living Room Lights"
+    id: living_room_lights
+    red: pca_0
+    green: pca_1
+    blue: pca_2
+  - platform: rgbw
+    name: "Living Room Lights 2"
+    red: pca_3
+    green: pca_4
+    blue: pca_5
+    white: pca_6
+  - platform: rgbww
+    name: "Living Room Lights 2"
+    red: pca_3
+    green: pca_4
+    blue: pca_5
+    cold_white: pca_6
+    warm_white: pca_6
+    cold_white_color_temperature: 153 mireds
+    warm_white_color_temperature: 500 mireds
+  - platform: cwww
+    name: "Living Room Lights 2"
+    cold_white: pca_6
+    warm_white: pca_6
+    cold_white_color_temperature: 153 mireds
+    warm_white_color_temperature: 500 mireds
+  - platform: fastled_clockless
+    chipset: WS2811
+    pin: GPIO23
+    num_leds: 60
+    rgb_order: BRG
+    max_refresh_rate: 20ms
+    power_supply: atx_power_supply
+    color_correct: [75%, 100%, 50%]
+    name: "FastLED WS2811 Light"
+    effects:
+    - fastled_color_wipe:
+    - fastled_color_wipe:
+        name: Color Wipe Effect With Custom Values
+        colors:
+        - red: 100%
+          green: 100%
+          blue: 100%
+          num_leds: 1
+        - red: 0%
+          green: 0%
+          blue: 0%
+          num_leds: 1
+        add_led_interval: 100ms
+        reverse: False
+    - fastled_scan:
+    - fastled_scan:
+        name: Scan Effect With Custom Values
+        move_interval: 100ms
+    - fastled_twinkle:
+    - fastled_twinkle:
+        name: Twinkle Effect With Custom Values
+        twinkle_probability: 5%
+        progress_interval: 4ms
+    - fastled_random_twinkle:
+    - fastled_random_twinkle:
+        name: Random Twinkle Effect With Custom Values
+        twinkle_probability: 5%
+        progress_interval: 32ms
+    - fastled_fireworks:
+    - fastled_fireworks:
+        name: Fireworks Effect With Custom Values
+        update_interval: 32ms
+        spark_probability: 10%
+        use_random_color: false
+        fade_out_rate: 120
+    - fastled_flicker:
+    - fastled_flicker:
+        name: Flicker Effect With Custom Values
+        update_interval: 16ms
+        intensity: 5%
+  - platform: fastled_spi
+    chipset: WS2801
+    data_pin: GPIO23
+    clock_pin: GPIO22
+    num_leds: 60
+    rgb_order: BRG
+    name: "FastLED SPI Light"
+
+remote_transmitter:
+  - pin: 32
+
+switch:
+  - platform: gpio
+    pin: GPIO25
+    name: "Living Room Dehumidifier"
+    icon: "mdi:restart"
+    inverted: True
+    command_topic: custom_command_topic
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    nec:
+      address: 0x4242
+      command: 0x8484
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    lg:
+      data: 4294967295
+      nbits: 28
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    samsung:
+      data: 0xABCDEF
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    sony:
+      data: 0xABCDEF
+      nbits: 12
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    panasonic:
+      address: 0x4004
+      command: 0x1000BCD
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    rc_switch_raw:
+      code: '001010011001111101011011'
+      protocol: 1
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    rc_switch_type_a:
+      group: '11001'
+      device: '01000'
+      state: True
+      protocol:
+        pulse_length: 175
+        sync: [1, 31]
+        zero: [1, 3]
+        one: [3, 1]
+        inverted: False
+    repeat: 25
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    rc_switch_type_b:
+      address: 4
+      channel: 2
+      state: True
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    rc_switch_type_c:
+      family: 'a'
+      group: 1
+      device: 2
+      state: True
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    id: living_room_lights_on
+    rc_switch_type_d:
+      group: 'a'
+      device: 2
+      state: True
+  - platform: remote_transmitter
+    name: "Panasonic TV Off"
+    id: living_room_lights_off
+    raw:
+      carrier_frequency: 35kHz
+      data:
+      - 1000
+      - -1000
+  - platform: template
+    name: Living Room Lights
+    optimistic: True
+    turn_on_action:
+    - switch.turn_on: living_room_lights_on
+    - output.set_level:
+        id: gpio_19
+        level: 50%
+    - output.set_level:
+        id: gpio_19
+        level: !lambda 'return 0.5;'
+    turn_off_action:
+    - switch.turn_on: living_room_lights_off
+    restore_state: False
+  - platform: restart
+    name: "Living Room Restart"
+  - platform: shutdown
+    name: "Living Room Shutdown"
+  - platform: output
+    name: "Generic Output"
+    output: pca_6
+  - platform: template
+    name: "Template Switch"
+    id: my_switch
+    lambda: |-
+      if (id(binary_sensor1).state) {
+        return true;
+      } else {
+        return {};
+      }
+      id(my_switch).publish_state(false);
+      id(my_switch).publish_state(true);
+      if (id(my_switch).state) {
+        // Switch is ON, do something here
+        id(my_switch).turn_off();
+        id(my_switch).turn_on();
+      } else {
+        // Switch is OFF, do something else here
+      }
+    optimistic: true
+    restore_state: True
+  - platform: uart
+    name: "UART String Output"
+    data: 'DataToSend'
+  - platform: uart
+    name: "UART Bytes Output"
+    data: [0xDE, 0xAD, 0xBE, 0xEF]
+  - platform: template
+    optimistic: true
+    name: Stepper Switch
+    turn_on_action:
+    - stepper.set_target:
+        id: my_stepper
+        target: !lambda |-
+          static int32_t i = 0;
+          i += 1000;
+          if (i > 5000) {
+            i = -5000;
+          }
+          return i;
+
+fan:
+  - platform: binary
+    output: gpio_26
+    name: "Living Room Fan 1"
+  - platform: speed
+    output: pca_6
+    name: "Living Room Fan 2"
+    speed:
+      low: 0.45
+      medium: 0.75
+      high: 1.0
+
+display:
+- platform: lcd_gpio
+  dimensions: 18x4
+  data_pins:
+  - GPIO19
+  - GPIO20
+  - GPIO21
+  - GPIO22
+  enable_pin: GPIO23
+  rs_pin: GPIO24
+  lambda: |-
+    it.print("Hello World!");
+- platform: lcd_pcf8574
+  dimensions: 18x4
+  address: 0x3F
+  lambda: |-
+    it.print("Hello World!");
+- platform: max7219
+  cs_pin: GPIO23
+  num_chips: 1
+  lambda: |-
+    it.print("01234567");
+- platform: nextion
+  lambda: |-
+    it.set_component_value("gauge", 50);
+    it.set_component_text("textview", "Hello World!");
+- platform: ssd1306_i2c
+  model: "SSD1306 128x64"
+  reset_pin: GPIO23
+  address: 0x3C
+  lambda: |-
+    it.rectangle(0, 0, it.get_width(), it.get_height());
+- platform: ssd1306_spi
+  model: "SSD1306 128x64"
+  cs_pin: GPIO23
+  dc_pin: GPIO23
+  reset_pin: GPIO23
+  lambda: |-
+    it.rectangle(0, 0, it.get_width(), it.get_height());
+- platform: waveshare_epaper
+  cs_pin: GPIO23
+  dc_pin: GPIO23
+  busy_pin: GPIO23
+  reset_pin: GPIO23
+  model: 2.90in
+  full_update_every: 30
+  lambda: |-
+    it.rectangle(0, 0, it.get_width(), it.get_height());
+
+remote_receiver:
+  pin: GPIO32
+  dump: all
+
+status_led:
+  pin: GPIO2
+
+pn532:
+  cs_pin: GPIO23
+  update_interval: 1s
+  on_tag:
+    - lambda: |-
+        ESP_LOGD("main", "Found tag %s", x.c_str());
+    - mqtt.publish:
+        topic: the/topic
+        payload: !lambda 'return x;'
+
+rdm6300:
+
+time:
+- platform: sntp
+  id: sntp_time
+  servers:
+  - 0.pool.ntp.org
+  - 1.pool.ntp.org
+  - 2.pool.ntp.org
+  on_time:
+    cron: '/30 0-30,30/5 * ? JAN-DEC MON,SAT-SUN,TUE-FRI'
+    then:
+      - lambda: 'ESP_LOGD("main", "time");'
+
+cover:
+  - platform: template
+    name: "Template Cover"
+    lambda: >-
+      if (id(binary_sensor1).state) {
+        return cover::COVER_OPEN;
+      } else {
+        return {};
+      }
+    optimistic: true
+
+debug:
+
+pcf8574:
+  - id: 'pcf8574_hub'
+    address: 0x21
+    pcf8575: False
+
+stepper:
+- platform: a4988
+  id: my_stepper
+  step_pin: GPIO23
+  dir_pin: GPIO24
+  sleep_pin: GPIO25
+  max_speed: 250 steps/s
+  acceleration: 100 steps/s^2
+  deceleration: 200 steps/s^2
+
+
+globals:
+- id: glob_int
+  type: int
+  restore_value: yes
+  initial_value: '0'
+- id: glob_float
+  type: float
+  restore_value: yes
+  initial_value: '0.0f'
+- id: glob_bool
+  type: bool
+  restore_value: no
+  initial_value: 'true'
+- id: glob_string
+  type: std::string
+  restore_value: no
+  # initial_value: ""

tests/test2.yaml

@@ -0,0 +1,168 @@
+esphomeyaml:
+  name: test2
+  platform: ESP32
+  board: nodemcu-32s
+  # Use latest upstream esphomelib git version.
+  esphomelib_version: dev
+  # Use this for testing while developing:
+  # esphomelib_version:
+  #   local: ~/path/to/esphomelib
+  use_custom_code: true
+  build_path: build/test2
+
+wifi:
+  ssid: 'MySSID'
+  password: 'password1'
+  reboot_timeout: 120s
+
+mqtt:
+  broker: '192.168.178.84'
+  port: 1883
+  username: 'debug'
+  password: 'debug'
+
+i2c:
+  sda: 21
+  scl: 22
+  scan: False
+
+spi:
+  clk_pin: GPIO21
+  mosi_pin: GPIO22
+  miso_pin: GPIO23
+
+uart:
+  tx_pin: GPIO22
+  rx_pin: GPIO23
+  baud_rate: 115200
+
+ota:
+  safe_mode: True
+  port: 3286
+
+logger:
+  level: DEBUG
+
+web_server:
+
+deep_sleep:
+  run_duration: 20s
+  sleep_duration: 50s
+
+sensor:
+  - platform: ble_rssi
+    mac_address: AC:37:43:77:5F:4C
+    name: "BLE Google Home Mini RSSI value"
+  - platform: xiaomi_miflora
+    mac_address: 94:2B:FF:5C:91:61
+    temperature:
+      name: "Xiaomi MiFlora Temperature"
+    moisture:
+      name: "Xiaomi MiFlora Moisture"
+    illuminance:
+      name: "Xiaomi MiFlora Illuminance"
+    conductivity:
+      name: "Xiaomi MiFlora Soil Conductivity"
+    battery_level:
+      name: "Xiaomi MiFlora Battery Level"
+  - platform: xiaomi_mijia
+    mac_address: 7A:80:8E:19:36:BA
+    temperature:
+      name: "Xiaomi MiJia Temperature"
+    humidity:
+      name: "Xiaomi MiJia Humidity"
+    battery_level:
+      name: "Xiaomi MiJia Battery Level"
+  - platform: mqtt_subscribe
+    name: "MQTT Subscribe Sensor 1"
+    topic: "mqtt/topic"
+    id: the_sensor
+    qos: 2
+    on_value:
+    - mqtt.publish_json:
+        topic: the/topic
+        payload: |-
+          root["key"] = id(the_sensor).value;
+          root["greeting"] = "Hello World";
+  - platform: pmsx003
+    type: PMSX003
+    pm_1_0:
+      name: "PM 1.0 Concentration"
+    pm_2_5:
+      name: "PM 2.5 Concentration"
+    pm_10_0:
+      name: "PM 10.0 Concentration"
+  - platform: pmsx003
+    type: PMS5003T
+    pm_2_5:
+      name: "PM 2.5 Concentration"
+    temperature:
+      name: "PMS Temperature"
+    humidity:
+      name: "PMS Humidity"
+  - platform: pmsx003
+    type: PMS5003ST
+    pm_2_5:
+      name: "PM 2.5 Concentration"
+    temperature:
+      name: "PMS Temperature"
+    humidity:
+      name: "PMS Humidity"
+    formaldehyde:
+      name: "PMS Formaldehyde Concentration"
+  - platform: cse7766
+    voltage:
+      name: "CSE7766 Voltage"
+    current:
+      name: "CSE7766 Current"
+    power:
+      name: "CSE776 Power"
+
+esp32_touch:
+  setup_mode: True
+
+binary_sensor:
+  - platform: esp32_ble_tracker
+    mac_address: AC:37:43:77:5F:4C
+    name: "ESP32 BLE Tracker Google Home Mini"
+  - platform: esp32_touch
+    name: "ESP32 Touch Pad GPIO27"
+    pin: GPIO27
+    threshold: 1000
+
+remote_receiver:
+  pin: GPIO32
+  dump: []
+
+esp32_ble_tracker:
+  scan_interval: 300s
+
+esp32_ble_beacon:
+  type: iBeacon
+  uuid: 'c29ce823-e67a-4e71-bff2-abaa32e77a98'
+
+status_led:
+  pin: GPIO2
+
+text_sensor:
+  - platform: version
+    name: "Esphomelib Version"
+    icon: mdi:icon
+    id: version_sensor
+    on_value:
+      - lambda: |-
+          ESP_LOGD("main", "The state is %s=%s", x.c_str(), id(version_sensor).state.c_str());
+      - script.execute: my_script
+  - platform: mqtt_subscribe
+    name: "MQTT Subscribe Text"
+    topic: "the/topic"
+    qos: 2
+  - platform: template
+    name: "Template Text Sensor"
+    lambda: |-
+      return {"Hello World"};
+
+script:
+  - id: my_script
+    then:
+      - lambda: 'ESP_LOGD("main", "Hello World!");'