Fix gitlab

* Add logger.log Action

* Simple schema

* Validate printf

* Improve error message

* Undo unfix tests :)

.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,233 @@
+---
+# 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:
+    - |
+      hassio-builder.sh \
+           -t . \
+           -i ottowinter/esphomeyaml-hassio-${ADDON_ARCH} \
+           -d "$CI_REGISTRY" \
+           --${ADDON_ARCH}
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:dev" \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:dev"
+  retry: 2
+
+# Generic deploy template
+.deploy-release: &deploy-release
+  <<: *docker-builder
+  stage: deploy
+  script:
+    - version=${CI_COMMIT_TAG:1}
+    - echo "Publishing release version ${version}"
+    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
+    - docker pull "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - |
+      docker tag \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+  only:
+  - /^v\d+\.\d+\.\d+$/
+  except:
+  - /^(?!master).+@/
+
+.deploy-beta: &deploy-beta
+  <<: *docker-builder
+  stage: deploy
+  script:
+    - version=${CI_COMMIT_TAG:1}
+    - echo "Publishing beta version ${version}"
+    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
+    - docker pull "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:beta"
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - |
+      docker tag \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}" \
+        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:beta"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:beta"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:beta"
+  only:
+  - /^v\d+\.\d+\.\d+b\d+$/
+  except:
+  - /^(?!rc).+@/
+
+# Build jobs
+build:normal:
+  <<: *docker-builder
+  stage: build
+  script:
+    - docker build -t "${CI_REGISTRY}/ottowinter/esphomeyaml:dev" .
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml:dev" \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml:dev"
+
+build:armhf:
+  <<: *build-hassio
+  variables:
+    ADDON_ARCH: armhf
+
+#build:aarch64:
+#   <<: *build
+#   variables:
+#     ADDON_ARCH: aarch64
+
+build:i386:
+  <<: *build-hassio
+  variables:
+    ADDON_ARCH: i386
+
+build:amd64:
+  <<: *build-hassio
+  variables:
+    ADDON_ARCH: amd64
+
+# 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,26 @@
 FROM python:2.7
 MAINTAINER Otto Winter <contact@otto-winter.com>
 
+RUN apt-get update && apt-get install -y \
+        python-pil \
+    && rm -rf /var/lib/apt/lists/*
+
 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
+RUN pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
 
 COPY docker/platformio.ini /usr/src/app/
 RUN platformio settings set enable_telemetry No && \
-    platformio lib --global install esphomelib && \
     platformio run -e espressif32 -e espressif8266; exit 0
 
-# Fix issue with static IP on ESP32: https://github.com/espressif/arduino-esp32/issues/1081
-RUN curl https://github.com/espressif/arduino-esp32/commit/144480637a718844b8f48f4392da8d4f622f2e5e.patch | \
-    patch /root/.platformio/packages/framework-arduinoespressif32/libraries/WiFi/src/WiFiGeneric.cpp
-
 COPY . .
-RUN pip install -e .
+RUN pip install --no-cache-dir -e . && \
+    pip install --no-cache-dir tzlocal pillow
 
 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,9 +1,10 @@
 # esphomeyaml for [esphomelib](https://github.com/OttoWinter/esphomelib)
 
-Getting Started Guide: https://esphomlib.com/esphomeyaml/getting-started.html
-Available Components: https://esphomelib.com/esphomeyaml/index.html
+### Getting Started Guide: https://esphomelib.com/esphomeyaml/guides/getting_started_command_line.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.
+### 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](https://www.home-assistant.io).
 
 esphomeyaml will:
 
@@ -25,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.aarch64

@@ -0,0 +1,21 @@
+# Dockerfile for aarch64 version of HassIO add-on
+FROM arm64v8/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 . .
+RUN pip install --no-cache-dir --no-binary :all: -e . && \
+    pip install --no-cache-dir --no-binary :all: tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

docker/Dockerfile.amd64

@@ -0,0 +1,21 @@
+# Dockerfile for amd64 version of HassIO add-on
+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 . .
+RUN pip install --no-cache-dir --no-binary :all: -e . && \
+    pip install --no-cache-dir --no-binary :all: tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

docker/Dockerfile.armhf

@@ -0,0 +1,31 @@
+# Dockerfile for armhf version of HassIO add-on
+FROM homeassistant/armhf-base:latest
+
+RUN apk add --no-cache \
+        python2 \
+        python2-dev \
+        py2-pip \
+        git \
+        gcc \
+        openssh \
+        libc6-compat \
+        jpeg-dev \
+        zlib-dev \
+        freetype-dev \
+        lcms2-dev \
+        openjpeg-dev \
+        tiff-dev \
+        libc-dev \
+        linux-headers \
+    && \
+    pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
+
+COPY docker/platformio-esp8266.ini /pio/platformio.ini
+RUN platformio run -d /pio; rm -rf /pio
+
+COPY . .
+RUN pip install --no-cache-dir --no-binary :all: -e . && \
+    pip install --no-cache-dir pillow tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

docker/Dockerfile.builder

@@ -0,0 +1,32 @@
+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/*
+
+COPY docker/hassio-builder.sh /usr/bin/
+
+WORKDIR /data

docker/Dockerfile.i386

@@ -0,0 +1,21 @@
+# Dockerfile for i386 version of HassIO add-on
+FROM i386/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 . .
+RUN pip install --no-cache-dir --no-binary :all: -e . && \
+    pip install --no-cache-dir --no-binary :all: tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

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/hassio-builder.sh

@@ -0,0 +1,318 @@
+#!/usr/bin/env bash
+# Based on Home Assistant's docker builder
+######################
+# Hass.io Build-env
+######################
+set -e
+
+echo -- "$@"
+
+#### Variable ####
+
+DOCKER_TIMEOUT=20
+DOCKER_PID=-1
+DOCKER_HUB=""
+DOCKER_CACHE="true"
+DOCKER_LOCAL="false"
+TARGET=""
+IMAGE=""
+BUILD_LIST=()
+BUILD_TASKS=()
+
+#### Misc functions ####
+
+function print_help() {
+    cat << EOF
+Hass.io build-env for ecosystem:
+docker run --rm homeassistant/{arch}-builder:latest [options]
+
+Options:
+  -h, --help
+        Display this help and exit.
+
+  Repository / Data
+    -t, --target <PATH_TO_BUILD>
+        Set local folder or path inside repository for build.
+
+  Version/Image handling
+    -i, --image <IMAGE_NAME>
+        Overwrite image name of build / support {arch}
+
+  Architecture
+    --armhf
+        Build for arm.
+    --amd64
+        Build for intel/amd 64bit.
+    --aarch64
+        Build for arm 64bit.
+    --i386
+        Build for intel/amd 32bit.
+    --all
+        Build all architecture.
+
+  Build handling
+    --no-cache
+       Disable cache for the build (from latest).
+    -d, --docker-hub <DOCKER_REPOSITORY>
+       Set or overwrite the docker repository.
+
+    Use the host docker socket if mapped into container:
+       /var/run/docker.sock
+
+EOF
+
+    exit 1
+}
+
+#### Docker functions ####
+
+function start_docker() {
+    local starttime
+    local endtime
+
+    if [ -S "/var/run/docker.sock" ]; then
+        echo "[INFO] Use host docker setup with '/var/run/docker.sock'"
+        DOCKER_LOCAL="true"
+        return 0
+    fi
+
+    echo "[INFO] Starting docker."
+    dockerd 2> /dev/null &
+    DOCKER_PID=$!
+
+    echo "[INFO] Waiting for docker to initialize..."
+    starttime="$(date +%s)"
+    endtime="$(date +%s)"
+    until docker info >/dev/null 2>&1; do
+        if [ $((endtime - starttime)) -le ${DOCKER_TIMEOUT} ]; then
+            sleep 1
+            endtime=$(date +%s)
+        else
+            echo "[ERROR] Timeout while waiting for docker to come up"
+            exit 1
+        fi
+    done
+    echo "[INFO] Docker was initialized"
+}
+
+
+function stop_docker() {
+    local starttime
+    local endtime
+
+    if [ "$DOCKER_LOCAL" == "true" ]; then
+        return 0
+    fi
+
+    echo "[INFO] Stopping in container docker..."
+    if [ "$DOCKER_PID" -gt 0 ] && kill -0 "$DOCKER_PID" 2> /dev/null; then
+        starttime="$(date +%s)"
+        endtime="$(date +%s)"
+
+        # Now wait for it to die
+        kill "$DOCKER_PID"
+        while kill -0 "$DOCKER_PID" 2> /dev/null; do
+            if [ $((endtime - starttime)) -le ${DOCKER_TIMEOUT} ]; then
+                sleep 1
+                endtime=$(date +%s)
+            else
+                echo "[ERROR] Timeout while waiting for container docker to die"
+                exit 1
+            fi
+        done
+    else
+        echo "[WARN] Your host might have been left with unreleased resources"
+    fi
+}
+
+function run_build() {
+    local build_dir=$1
+    local repository=$2
+    local image=$3
+    local version=$4
+    local build_arch=$5
+    local docker_cli=("${!6}")
+
+    local push_images=()
+
+    # Overwrites
+    if [ ! -z "$DOCKER_HUB" ]; then repository="$DOCKER_HUB"; fi
+    if [ ! -z "$IMAGE" ]; then image="$IMAGE"; fi
+
+    # Init Cache
+    if [ "$DOCKER_CACHE" == "true" ]; then
+        echo "[INFO] Init cache for $repository/$image:$version"
+        if docker pull "$repository/$image:latest" > /dev/null 2>&1; then
+            docker_cli+=("--cache-from" "$repository/$image:latest")
+        else
+            docker_cli+=("--no-cache")
+            echo "[WARN] No cache image found. Cache is disabled for build"
+        fi
+    else
+        docker_cli+=("--no-cache")
+    fi
+
+    # Build image
+    echo "[INFO] Run build for $repository/$image:$version"
+    docker build --pull -t "$repository/$image:$version" \
+        --label "io.hass.version=$version" \
+        --label "io.hass.arch=$build_arch" \
+        -f "$TARGET/docker/Dockerfile.$build_arch" \
+        "${docker_cli[@]}" \
+        "$build_dir"
+
+    echo "[INFO] Finish build for $repository/$image:$version"
+    docker tag "$repository/$image:$version" "$repository/$image:dev"
+}
+
+
+#### HassIO functions ####
+
+function build_addon() {
+    local build_arch=$1
+
+    local docker_cli=()
+    local image=""
+    local repository=""
+    local raw_image=""
+    local name=""
+    local description=""
+    local url=""
+    local args=""
+
+    # Read addon config.json
+    name="$(jq --raw-output '.name // empty' "$TARGET/esphomeyaml/config.json" | sed "s/'//g")"
+    description="$(jq --raw-output '.description // empty' "$TARGET/esphomeyaml/config.json" | sed "s/'//g")"
+    url="$(jq --raw-output '.url // empty' "$TARGET/esphomeyaml/config.json")"
+    version="$(jq --raw-output '.version' "$TARGET/esphomeyaml/config.json")"
+    raw_image="$(jq --raw-output '.image // empty' "$TARGET/esphomeyaml/config.json")"
+
+    # Read data from image
+    if [ ! -z "$raw_image" ]; then
+        repository="$(echo "$raw_image" | cut -f 1 -d '/')"
+        image="$(echo "$raw_image" | cut -f 2 -d '/')"
+    fi
+
+    # Set additional labels
+    docker_cli+=("--label" "io.hass.name=$name")
+    docker_cli+=("--label" "io.hass.description=$description")
+    docker_cli+=("--label" "io.hass.type=addon")
+
+    if [ ! -z "$url" ]; then
+        docker_cli+=("--label" "io.hass.url=$url")
+    fi
+
+    # Start build
+    run_build "$TARGET" "$repository" "$image" "$version" \
+        "$build_arch" docker_cli[@]
+}
+
+#### initialized cross-build ####
+
+function init_crosscompile() {
+    echo "[INFO] Setup crosscompiling feature"
+    (
+        mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc
+        update-binfmts --enable qemu-arm
+        update-binfmts --enable qemu-aarch64
+    ) > /dev/null 2>&1 || echo "[WARN] Can't enable crosscompiling feature"
+}
+
+
+function clean_crosscompile() {
+    echo "[INFO] Clean crosscompiling feature"
+    if [ -f /proc/sys/fs/binfmt_misc ]; then
+        umount /proc/sys/fs/binfmt_misc || true
+    fi
+
+    (
+        update-binfmts --disable qemu-arm
+        update-binfmts --disable qemu-aarch64
+    ) > /dev/null 2>&1 || echo "[WARN] No crosscompiling feature found for cleanup"
+}
+
+#### Error handling ####
+
+function error_handling() {
+    stop_docker
+    clean_crosscompile
+
+    exit 1
+}
+trap 'error_handling' SIGINT SIGTERM
+
+#### Parse arguments ####
+
+while [[ $# -gt 0 ]]; do
+    key=$1
+    case ${key} in
+        -h|--help)
+            print_help
+            ;;
+        -t|--target)
+            TARGET=$2
+            shift
+            ;;
+        -i|--image)
+            IMAGE=$2
+            shift
+            ;;
+        --no-cache)
+            DOCKER_CACHE="false"
+            ;;
+        -d|--docker-hub)
+            DOCKER_HUB=$2
+            shift
+            ;;
+        --armhf)
+            BUILD_LIST+=("armhf")
+            ;;
+        --amd64)
+            BUILD_LIST+=("amd64")
+            ;;
+        --i386)
+            BUILD_LIST+=("i386")
+            ;;
+        --aarch64)
+            BUILD_LIST+=("aarch64")
+            ;;
+        --all)
+            BUILD_LIST=("armhf" "amd64" "i386" "aarch64")
+            ;;
+
+        *)
+            echo "[WARN] $0 : Argument '$1' unknown will be Ignoring"
+            ;;
+    esac
+    shift
+done
+
+# Check if an architecture is available
+if [ "${#BUILD_LIST[@]}" -eq 0 ]; then
+    echo "[ERROR] You need select an architecture for build!"
+    exit 1
+fi
+
+
+#### Main ####
+
+mkdir -p /data
+
+# Setup docker env
+init_crosscompile
+start_docker
+
+# Select arch build
+for arch in "${BUILD_LIST[@]}"; do
+    (build_addon "$arch") &
+    BUILD_TASKS+=($!)
+done
+
+# Wait until all build jobs are done
+wait "${BUILD_TASKS[@]}"
+
+# Cleanup docker env
+clean_crosscompile
+stop_docker
+
+exit 0

docker/platformio-esp8266.ini

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

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.0b1",
+  "slug": "esphomeyaml-beta",
+  "description": "Beta version of 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
+  },
+  "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,59 @@
+# Dockerfile for HassIO add-on
+ARG BUILD_FROM=ubuntu:bionic
+FROM ${BUILD_FROM}
+
+# Re-declare BUILD_FROM to fix weird docker issue
+ARG BUILD_FROM
+
+# On amd64 and alike, using ubuntu as the base is better as building
+# for the ESP32 only works with glibc (and ubuntu). However, on armhf
+# the build toolchain frequently procudes segfaults under ubuntu.
+#  -> Use ubuntu for most architectures, except alpine for armhf
+#
+# * python and related required because this is a python project
+# * git required for platformio library dependencies downloads
+# * libc6-compat and openssh required on alpine for weird reasons
+# * disable platformio telemetry on install
+RUN /bin/bash -c "if [[ '$BUILD_FROM' = *\"ubuntu\"* ]]; then \
+      apt-get update && apt-get install -y --no-install-recommends \
+        python python-pip python-setuptools python-pil git && \
+      rm -rf /var/lib/apt/lists/* /tmp/*; \
+    else \
+       apk add --no-cache \
+          python2 \
+          python2-dev \
+          py2-pip \
+          git \
+          gcc \
+          openssh \
+          libc6-compat \
+          jpeg-dev \
+          zlib-dev \
+          freetype-dev \
+          lcms2-dev \
+          openjpeg-dev \
+          tiff-dev \
+          libc-dev \
+          linux-headers; \
+    fi" && \
+    pip install --no-cache-dir platformio && \
+    platformio settings set enable_telemetry No
+
+
+# Create fake project to make platformio install all depdencies.
+# * Ignore build errors from platformio - empty project
+# * On alpine, only install ESP8266 toolchain
+COPY platformio.ini /pio/platformio.ini
+RUN /bin/bash -c "if [[ '$BUILD_FROM' = *\"ubuntu\"* ]]; then \
+      platformio run -e espressif32 -e espressif8266 -d /pio; exit 0; \
+    else \
+      echo \"\$(head -8 /pio/platformio.ini)\" >/pio/platformio.ini; \
+      platformio run -e espressif8266 -d /pio; exit 0; \
+    fi"
+
+# Install latest esphomeyaml from git
+RUN pip install --no-cache-dir \
+      git+git://github.com/OttoWinter/esphomeyaml.git && \
+    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": "arm64v8/ubuntu:bionic",
+        "amd64": "ubuntu:bionic",
+        "armhf": "homeassistant/armhf-base:latest",
+        "i386": "i386/ubuntu:bionic"
+    },
+    "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

@@ -5,173 +5,244 @@ 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
+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, quote, statement, relative_path
+from esphomeyaml.util import safe_print
 
 _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()
+
+    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_platformio(*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(quote(x) for x in cmd)
     _LOGGER.info(u"Running:  %s", full_cmd)
     try:
-        import platformio.__main__
+        func = kwargs.get('main')
+        if func is None:
+            import platformio.__main__
+            func = platformio.__main__.main
         sys.argv = list(cmd)
         sys.exit = mock_exit
-        return platformio.__main__.main()
+        return func() or 0
     except KeyboardInterrupt:
         return 1
-    except SystemExit as e:
-        return e.args[0]
-    except Exception as e:
-        _LOGGER.error(u"Running platformio failed: %s", e)
+    except SystemExit as err:
+        return err.args[0]
+    except Exception as err:  # pylint: disable=broad-except
+        _LOGGER.error(u"Running platformio failed: %s", err)
         _LOGGER.error(u"Please try running %s locally.", full_cmd)
     finally:
         sys.argv = orig_argv
         sys.exit = orig_exit
 
 
-def run_miniterm(config, port):
-    from serial.tools import miniterm
-    baud_rate = config.get(CONF_LOGGER, {}).get(CONF_BAUD_RATE, 115200)
-    sys.argv = ['miniterm', '--raw', '--exit-char', '3']
-    miniterm.main(
-        default_port=port,
-        default_baudrate=baud_rate)
+def 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)
+
+    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)
 
 
 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))
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    command = ['platformio', 'run', '-d', build_path]
+    if args.verbose:
+        command.append('-v')
+    return run_platformio(*command)
 
 
-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')
+    # pylint: disable=protected-access
+    return run_platformio('esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
+                          '--chip', 'esp8266', '--port', port, 'write_flash', '0x0',
+                          path, main=esptool._main)
+
+
+def upload_program(config, args, port):
+    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)
+        command = ['platformio', 'run', '-d', build_path,
+                   '-t', 'upload', '--upload-port', port]
+        if args.verbose:
+            command.append('-v')
+        return run_platformio(*command)
+
+    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)
+def setup_log(debug=False):
+    log_level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(level=log_level)
     fmt = "%(levelname)s [%(name)s] %(message)s"
     colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
     datefmt = '%H:%M:%S'
@@ -196,27 +267,154 @@ 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_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,
+}
+
+
+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 +422,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 +438,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 +451,60 @@ 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')
+
+    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,276 @@
+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
+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):
+        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"".format(key, key2))
+        validator = ACTION_REGISTRY[key][0]
+        value[i] = {
+            CONF_ACTION_ID: cv.declare_variable_id(None)(item[CONF_ACTION_ID]),
+            key: validator(item[key])
+        }
+    return value
+
+
+ACTION_REGISTRY = ServiceRegistry()
+
+# pylint: disable=invalid-name
+DelayAction = esphomelib_ns.DelayAction
+LambdaAction = esphomelib_ns.LambdaAction
+IfAction = esphomelib_ns.IfAction
+UpdateComponentAction = esphomelib_ns.UpdateComponentAction
+Automation = esphomelib_ns.Automation
+
+CONDITIONS_SCHEMA = vol.All(cv.ensure_list, [cv.templatable({
+    cv.GenerateID(CONF_CONDITION_ID): cv.declare_variable_id(None),
+    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_,
+})])
+
+# pylint: disable=invalid-name
+AndCondition = esphomelib_ns.AndCondition
+OrCondition = esphomelib_ns.OrCondition
+RangeCondition = esphomelib_ns.RangeCondition
+LambdaCondition = esphomelib_ns.LambdaCondition
+
+
+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:
+                    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(None),
+    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(None),
+    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(None),
+})
+
+
+@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,28 +1,21 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_RATE
-from esphomeyaml.helpers import App, Pvariable, RawExpression, add, HexIntLiteral
+from esphomeyaml.helpers import App, Pvariable
 
 DEPENDENCIES = ['i2c']
 
-ADS1115_COMPONENT_CLASS = 'sensor::ADS1115Component'
+ADS1115Component = sensor.sensor_ns.ADS1115Component
 
-RATES = {
-    8: 'ADS1115_RATE_8',
-    16: 'ADS1115_RATE_16',
-    32: 'ADS1115_RATE_32',
-    64: 'ADS1115_RATE_64',
-    128: 'ADS1115_RATE_128',
-    250: 'ADS1115_RATE_250',
-    475: 'ADS1115_RATE_475',
-    860: 'ADS1115_RATE_860',
-}
+RATE_REMOVE_MESSAGE = """The rate option has been removed in 1.5.0 and is no longer required."""
 
 ADS1115_SCHEMA = vol.Schema({
-    cv.GenerateID('ads1115'): cv.register_variable_id,
+    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()))),
+
+    vol.Optional(CONF_RATE): cv.invalid(RATE_REMOVE_MESSAGE)
 })
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [ADS1115_SCHEMA])
@@ -30,8 +23,8 @@ CONFIG_SCHEMA = vol.All(cv.ensure_list, [ADS1115_SCHEMA])
 
 def to_code(config):
     for conf in config:
-        address = HexIntLiteral(conf[CONF_ADDRESS])
-        rhs = App.make_ads1115_component(address)
-        ads1115 = Pvariable(ADS1115_COMPONENT_CLASS, conf[CONF_ID], rhs)
-        if CONF_RATE in conf:
-            add(ads1115.set_rate(RawExpression(RATES[conf[CONF_RATE]])))
+        rhs = App.make_ads1115_component(conf[CONF_ADDRESS])
+        Pvariable(conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphomeyaml/components/binary_sensor/__init__.py

@@ -1,12 +1,13 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_INVERTED
-from esphomeyaml.helpers import add, setup_mqtt_component
-
-PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_INVERTED): cv.boolean,
-})
+from esphomeyaml import automation
+from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_ID, CONF_INTERNAL, CONF_INVERTED, \
+    CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_MQTT_ID, CONF_ON_CLICK, CONF_ON_DOUBLE_CLICK, \
+    CONF_ON_PRESS, CONF_ON_RELEASE, CONF_TRIGGER_ID, CONF_FILTERS, CONF_INVERT, CONF_DELAYED_ON, \
+    CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT
+from esphomeyaml.helpers import App, NoArg, Pvariable, add, add_job, esphomelib_ns, \
+    setup_mqtt_component, bool_, process_lambda, ArrayInitializer
 
 DEVICE_CLASSES = [
     '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
@@ -15,15 +16,142 @@ DEVICE_CLASSES = [
     'sound', 'vibration', 'window'
 ]
 
-DEVICE_CLASSES_MSG = "Unknown device class. Must be one of {}".format(', '.join(DEVICE_CLASSES))
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
-MQTT_BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
-    vol.Optional(CONF_DEVICE_CLASS): vol.All(vol.Lower,
-                                             vol.Any(*DEVICE_CLASSES, msg=DEVICE_CLASSES_MSG)),
 })
 
+binary_sensor_ns = esphomelib_ns.namespace('binary_sensor')
+PressTrigger = binary_sensor_ns.PressTrigger
+ReleaseTrigger = binary_sensor_ns.ReleaseTrigger
+ClickTrigger = binary_sensor_ns.ClickTrigger
+DoubleClickTrigger = binary_sensor_ns.DoubleClickTrigger
+BinarySensor = binary_sensor_ns.BinarySensor
+InvertFilter = binary_sensor_ns.InvertFilter
+LambdaFilter = binary_sensor_ns.LambdaFilter
+DelayedOnFilter = binary_sensor_ns.DelayedOnFilter
+DelayedOffFilter = binary_sensor_ns.DelayedOffFilter
+HeartbeatFilter = binary_sensor_ns.HeartbeatFilter
+MQTTBinarySensorComponent = binary_sensor_ns.MQTTBinarySensorComponent
 
-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)
+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))])
+
+BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTBinarySensorComponent),
+    cv.GenerateID(): cv.declare_variable_id(BinarySensor),
+
+    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_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)
+
+    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)
+
+
+BUILD_FLAGS = '-DUSE_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/esp32_ble_tracker.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_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
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    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)

esphomeyaml/components/binary_sensor/esp32_touch.py

@@ -0,0 +1,53 @@
+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
+
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    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'

esphomeyaml/components/binary_sensor/gpio.py

@@ -3,19 +3,24 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import binary_sensor
-from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_ID, CONF_INVERTED, CONF_NAME, CONF_PIN
-from esphomeyaml.helpers import App, add, exp_gpio_input_pin, variable
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN
+from esphomeyaml.helpers import App, gpio_input_pin_expression, variable, Application
 
-PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('gpio_binary_sensor'): cv.register_variable_id,
-    vol.Required(CONF_PIN): pins.GPIO_INPUT_PIN_SCHEMA
-}).extend(binary_sensor.MQTT_BINARY_SENSOR_SCHEMA.schema)
+MakeGPIOBinarySensor = Application.MakeGPIOBinarySensor
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeGPIOBinarySensor),
+    vol.Required(CONF_PIN): pins.gpio_input_pin_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)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/nextion.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.components.display.nextion import Nextion
+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'
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    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)

esphomeyaml/components/binary_sensor/pn532.py

@@ -0,0 +1,42 @@
+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
+
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_UID): validate_uid,
+    cv.GenerateID(CONF_PN532_ID): cv.use_variable_id(PN532Component)
+}))
+
+
+def to_code(config):
+    hub = None
+    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)

esphomeyaml/components/binary_sensor/rdm6300.py

@@ -0,0 +1,23 @@
+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'
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_UID): cv.uint32_t,
+    cv.GenerateID(CONF_RDM6300_ID): cv.use_variable_id(rdm6300.RDM6300Component)
+}))
+
+
+def to_code(config):
+    hub = None
+    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)

esphomeyaml/components/binary_sensor/remote_receiver.py

@@ -0,0 +1,121 @@
+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.RemoteReceiver
+LGReceiver = remote_ns.LGReceiver
+NECReceiver = remote_ns.NECReceiver
+PanasonicReceiver = remote_ns.PanasonicReceiver
+RawReceiver = remote_ns.RawReceiver
+SamsungReceiver = remote_ns.SamsungReceiver
+SonyReceiver = remote_ns.SonyReceiver
+RCSwitchRawReceiver = remote_ns.RCSwitchRawReceiver
+RCSwitchTypeAReceiver = remote_ns.RCSwitchTypeAReceiver
+RCSwitchTypeBReceiver = remote_ns.RCSwitchTypeBReceiver
+RCSwitchTypeCReceiver = remote_ns.RCSwitchTypeCReceiver
+RCSwitchTypeDReceiver = remote_ns.RCSwitchTypeDReceiver
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    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):
+    remote = None
+    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'

esphomeyaml/components/binary_sensor/status.py

@@ -1,14 +1,21 @@
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import binary_sensor
-from esphomeyaml.const import CONF_ID, CONF_NAME
-from esphomeyaml.helpers import App, Pvariable
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, variable
 
-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.MakeStatusBinarySensor
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeStatusBinarySensor),
+}))
 
 
 def to_code(config):
     rhs = App.make_status_binary_sensor(config[CONF_NAME])
-    gpio = Pvariable('binary_sensor::MQTTBinarySensorComponent', config[CONF_ID], rhs)
-    binary_sensor.setup_mqtt_binary_sensor(gpio.Pmqtt, config)
+    status = variable(config[CONF_MAKE_ID], rhs)
+    binary_sensor.setup_binary_sensor(status.Pstatus, status.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'

esphomeyaml/components/binary_sensor/template.py

@@ -0,0 +1,28 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME
+from esphomeyaml.helpers import App, Application, process_lambda, variable, optional, bool_, add
+
+MakeTemplateBinarySensor = Application.MakeTemplateBinarySensor
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateBinarySensor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+}))
+
+
+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)
+
+    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'

esphomeyaml/components/cover/__init__.py

@@ -0,0 +1,90 @@
+import voluptuous as vol
+
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
+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
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+cover_ns = esphomelib_ns.namespace('cover')
+Cover = cover_ns.Cover
+MQTTCoverComponent = cover_ns.MQTTCoverComponent
+CoverState = cover_ns.CoverState
+COVER_OPEN = cover_ns.COVER_OPEN
+COVER_CLOSED = cover_ns.COVER_CLOSED
+OpenAction = cover_ns.OpenAction
+CloseAction = cover_ns.CloseAction
+StopAction = cover_ns.StopAction
+
+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(None),
+})
+
+
+@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(None),
+})
+
+
+@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(None),
+})
+
+
+@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)

esphomeyaml/components/cover/template.py

@@ -0,0 +1,47 @@
+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
+
+MakeTemplateCover = Application.MakeTemplateCover
+
+PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateCover),
+    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),
+}), 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)
+
+    if CONF_LAMBDA in config:
+        template_ = None
+        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'

esphomeyaml/components/dallas.py

@@ -2,19 +2,23 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
+from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
 from esphomeyaml.helpers import App, Pvariable
 
-DALLAS_COMPONENT_CLASS = 'sensor::DallasComponent'
+DallasComponent = sensor.sensor_ns.DallasComponent
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
-    cv.GenerateID('dallas'): cv.register_variable_id,
+    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,
 })])
 
 
 def to_code(config):
     for conf in config:
         rhs = App.make_dallas_component(conf[CONF_PIN], conf.get(CONF_UPDATE_INTERVAL))
-        Pvariable(DALLAS_COMPONENT_CLASS, conf[CONF_ID], rhs)
+        Pvariable(conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphomeyaml/components/debug.py

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

esphomeyaml/components/deep_sleep.py

@@ -0,0 +1,93 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv, pins
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_RUN_CYCLES, CONF_RUN_DURATION, \
+    CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
+from esphomeyaml.helpers import App, Pvariable, add, gpio_input_pin_expression, esphomelib_ns, \
+    TemplateArguments, get_variable
+
+
+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.DeepSleepComponent
+EnterDeepSleepAction = esphomelib_ns.EnterDeepSleepAction
+PreventDeepSleepAction = esphomelib_ns.PreventDeepSleepAction
+
+WAKEUP_PIN_MODES = {
+    'IGNORE': esphomelib_ns.WAKEUP_PIN_MODE_IGNORE,
+    'KEEP_AWAKE': esphomelib_ns.WAKEUP_PIN_MODE_KEEP_AWAKE,
+    'INVERT_WAKEUP': esphomelib_ns.WAKEUP_PIN_MODE_INVERT_WAKEUP,
+}
+
+CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
+
+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_RUN_CYCLES): cv.positive_int,
+    vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
+})
+
+
+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:
+        pin = None
+        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]))
+
+
+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.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,72 @@
+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
+
+GPIOLCDDisplay = display.display_ns.GPIOLCDDisplay
+LCDDisplay = display.display_ns.LCDDisplay
+LCDDisplayRef = LCDDisplay.operator('ref')
+
+
+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,
+})
+
+
+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)
+
+
+BUILD_FLAGS = '-DUSE_LCD_DISPLAY'

esphomeyaml/components/display/lcd_pcf8574.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import display
+from esphomeyaml.components.display.lcd_gpio import LCDDisplayRef, validate_lcd_dimensions
+from esphomeyaml.const import CONF_ADDRESS, CONF_DIMENSIONS, CONF_ID, CONF_LAMBDA
+from esphomeyaml.helpers import App, Pvariable, add, process_lambda
+
+DEPENDENCIES = ['i2c']
+
+PCF8574LCDDisplay = display.display_ns.PCF8574LCDDisplay
+
+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,
+})
+
+
+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)
+
+
+BUILD_FLAGS = ['-DUSE_LCD_DISPLAY', '-DUSE_LCD_DISPLAY_PCF8574']

esphomeyaml/components/display/max7219.py

@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display
+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
+
+DEPENDENCIES = ['spi']
+
+MAX7219Component = display.display_ns.MAX7219Component
+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)),
+})
+
+
+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)
+
+
+BUILD_FLAGS = '-DUSE_MAX7219'

esphomeyaml/components/display/nextion.py

@@ -0,0 +1,32 @@
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import display
+from esphomeyaml.components.uart import UARTComponent
+from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, process_lambda
+
+DEPENDENCIES = ['uart']
+
+Nextion = display.display_ns.Nextion
+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),
+})
+
+
+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)
+
+
+BUILD_FLAGS = '-DUSE_NEXTION'

esphomeyaml/components/display/ssd1306_i2c.py

@@ -0,0 +1,46 @@
+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
+
+DEPENDENCIES = ['i2c']
+
+I2CSSD1306 = display.display_ns.I2CSSD1306
+
+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,
+})
+
+
+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)
+
+
+BUILD_FLAGS = '-DUSE_SSD1306'

esphomeyaml/components/display/ssd1306_spi.py

@@ -0,0 +1,68 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display
+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
+
+DEPENDENCIES = ['spi']
+
+SPISSD1306 = display.display_ns.SPISSD1306
+
+MODELS = {
+    'SSD1306_128X32': display.display_ns.SSD1306_MODEL_128_32,
+    'SSD1306_128X64': display.display_ns.SSD1306_MODEL_128_64,
+    'SSD1306_96X16': display.display_ns.SSD1306_MODEL_96_16,
+    'SSD1306_64X48': display.display_ns.SSD1306_MODEL_64_48,
+    'SH1106_128X32': display.display_ns.SH1106_MODEL_128_32,
+    'SH1106_128X64': display.display_ns.SH1106_MODEL_128_64,
+    'SH1106_96X16': display.display_ns.SH1106_MODEL_96_16,
+    'SH1106_64X48': display.display_ns.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,
+})
+
+
+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)
+
+
+BUILD_FLAGS = '-DUSE_SSD1306'

esphomeyaml/components/display/waveshare_epaper.py

@@ -0,0 +1,84 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display
+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
+
+DEPENDENCIES = ['spi']
+
+WaveshareEPaperTypeA = display.display_ns.WaveshareEPaperTypeA
+WaveshareEPaper = display.display_ns.WaveshareEPaper
+
+MODELS = {
+    '1.54in': ('a', display.display_ns.WAVESHARE_EPAPER_1_54_IN),
+    '2.13in': ('a', display.display_ns.WAVESHARE_EPAPER_2_13_IN),
+    '2.90in': ('a', display.display_ns.WAVESHARE_EPAPER_2_9_IN),
+    '2.70in': ('b', display.display_ns.WAVESHARE_EPAPER_2_7_IN),
+    '4.20in': ('b', display.display_ns.WAVESHARE_EPAPER_4_2_IN),
+    '7.50in': ('b', display.display_ns.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(None),
+    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,
+}), 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)
+
+
+BUILD_FLAGS = '-DUSE_WAVESHARE_EPAPER'

esphomeyaml/components/esp32_ble.py

@@ -0,0 +1,5 @@
+from esphomeyaml import config_validation as cv
+
+CONFIG_SCHEMA = cv.invalid("The 'esp32_ble' component has been renamed to the 'esp32_ble_tracker' "
+                           "component in order to avoid confusion with the new 'esp32_ble_beacon' "
+                           "component.")

esphomeyaml/components/esp32_ble_beacon.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32, CONF_UUID, CONF_TYPE
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, RawExpression, ArrayInitializer
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+ESP32BLEBeacon = esphomelib_ns.ESP32BLEBeacon
+
+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,
+})
+
+
+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]))
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_BEACON'

esphomeyaml/components/esp32_ble_tracker.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, ArrayInitializer
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONF_ESP32_BLE_ID = 'esp32_ble_id'
+ESP32BLETracker = esphomelib_ns.ESP32BLETracker
+
+CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLETracker),
+    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds,
+})
+
+
+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]))
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_TRACKER'

esphomeyaml/components/esp32_touch.py

@@ -0,0 +1,84 @@
+import voluptuous as vol
+
+from esphomeyaml import config_validation as cv
+from esphomeyaml.components import binary_sensor
+from esphomeyaml.const import CONF_ID, CONF_SETUP_MODE, CONF_IIR_FILTER, \
+    CONF_SLEEP_DURATION, CONF_MEASUREMENT_DURATION, CONF_LOW_VOLTAGE_REFERENCE, \
+    CONF_HIGH_VOLTAGE_REFERENCE, CONF_VOLTAGE_ATTENUATION, ESP_PLATFORM_ESP32
+from esphomeyaml.core import TimePeriod
+from esphomeyaml.helpers import App, Pvariable, add, global_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+
+def validate_voltage(values):
+    def validator(value):
+        if isinstance(value, float) and value.is_integer():
+            value = int(value)
+        value = cv.string(value)
+        if not value.endswith('V'):
+            value += 'V'
+        return cv.one_of(*values)(value)
+    return validator
+
+
+LOW_VOLTAGE_REFERENCE = {
+    '0.5V': global_ns.TOUCH_LVOLT_0V5,
+    '0.6V': global_ns.TOUCH_LVOLT_0V6,
+    '0.7V': global_ns.TOUCH_LVOLT_0V7,
+    '0.8V': global_ns.TOUCH_LVOLT_0V8,
+}
+HIGH_VOLTAGE_REFERENCE = {
+    '2.4V': global_ns.TOUCH_HVOLT_2V4,
+    '2.5V': global_ns.TOUCH_HVOLT_2V5,
+    '2.6V': global_ns.TOUCH_HVOLT_2V6,
+    '2.7V': global_ns.TOUCH_HVOLT_2V7,
+}
+VOLTAGE_ATTENUATION = {
+    '1.5V': global_ns.TOUCH_HVOLT_ATTEN_1V5,
+    '1V': global_ns.TOUCH_HVOLT_ATTEN_1V,
+    '0.5V': global_ns.TOUCH_HVOLT_ATTEN_0V5,
+    '0V': global_ns.TOUCH_HVOLT_ATTEN_0V,
+}
+
+ESP32TouchComponent = binary_sensor.binary_sensor_ns.ESP32TouchComponent
+
+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),
+})
+
+
+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))
+
+
+BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'

esphomeyaml/components/fan/__init__.py

@@ -1,23 +1,130 @@
 import voluptuous as vol
 
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
 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
+from esphomeyaml.helpers import Application, Pvariable, add, esphomelib_ns, setup_mqtt_component, \
+    TemplateArguments, get_variable, templatable, bool_
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+fan_ns = esphomelib_ns.namespace('fan')
+FanState = fan_ns.FanState
+MQTTFanComponent = fan_ns.MQTTFanComponent
+MakeFan = Application.MakeFan
+TurnOnAction = fan_ns.TurnOnAction
+TurnOffAction = fan_ns.TurnOffAction
+ToggleAction = fan_ns.ToggleAction
+FanSpeed = fan_ns.FanSpeed
+FAN_SPEED_OFF = fan_ns.FAN_SPEED_OFF
+FAN_SPEED_LOW = fan_ns.FAN_SPEED_LOW
+FAN_SPEED_MEDIUM = fan_ns.FAN_SPEED_MEDIUM
+FAN_SPEED_HIGH = fan_ns.FAN_SPEED_HIGH
+
+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(None),
+})
+
+
+@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(None),
+})
+
+
+@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(None),
+    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

esphomeyaml/components/fan/binary.py

@@ -2,22 +2,28 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import fan
-from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
 from esphomeyaml.helpers import App, add, get_variable, variable
 
-PLATFORM_SCHEMA = fan.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('binary_fan'): cv.register_variable_id,
-    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(None),
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(None),
+}))
 
 
 def to_code(config):
-    output = get_variable(config[CONF_OUTPUT])
+    output = None
+    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)
     add(fan_struct.Poutput.set_binary(output))
     if CONF_OSCILLATION_OUTPUT in config:
-        oscillation_output = get_variable(config[CONF_OSCILLATION_OUTPUT])
+        oscillation_output = None
+        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)

esphomeyaml/components/fan/speed.py

@@ -2,32 +2,34 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import fan
-from esphomeyaml.const import CONF_HIGH, CONF_ID, CONF_LOW, \
-    CONF_MEDIUM, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_SPEED, \
-    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphomeyaml.const import CONF_HIGH, CONF_LOW, CONF_MAKE_ID, CONF_MEDIUM, CONF_NAME, \
+    CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_SPEED, CONF_SPEED_COMMAND_TOPIC, \
+    CONF_SPEED_STATE_TOPIC
 from esphomeyaml.helpers import App, add, get_variable, variable
 
-PLATFORM_SCHEMA = fan.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('speed_fan'): cv.register_variable_id,
-    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(None),
     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(None),
     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,
     }),
-})
+}))
 
 
 def to_code(config):
-    output = get_variable(config[CONF_OUTPUT])
+    output = None
+    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]))
@@ -35,6 +37,9 @@ def to_code(config):
         add(fan_struct.Poutput.set_speed(output))
 
     if CONF_OSCILLATION_OUTPUT in config:
-        oscillation_output = get_variable(config[CONF_OSCILLATION_OUTPUT])
+        oscillation_output = None
+        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)

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.Font
+Glyph = display.display_ns.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/i2c.py

@@ -2,15 +2,32 @@ 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
+
+I2CComponent = esphomelib_ns.I2CComponent
 
 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.")
 })
 
 
 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]))
+
+
+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.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 +1,6 @@
 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)
+def CONFIG_SCHEMA(config):
+    raise vol.Invalid("The ir_transmitter component has been renamed to "
+                      "remote_transmitter because of 433MHz signal support.")

esphomeyaml/components/light/__init__.py

@@ -1,13 +1,450 @@
+import voluptuous as vol
+
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
 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_DEFAULT_TRANSITION_LENGTH, CONF_DURATION, CONF_EFFECTS, CONF_EFFECT_ID, \
+    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, CONF_FLASH_LENGTH, CONF_COLOR_TEMPERATURE, \
+    CONF_EFFECT
+from esphomeyaml.helpers import Application, ArrayInitializer, Pvariable, RawExpression, \
+    StructInitializer, add, add_job, esphomelib_ns, process_lambda, setup_mqtt_component, \
+    get_variable, TemplateArguments, templatable, uint32, float_, std_string
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
-}).extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA.schema)
+})
+
+light_ns = esphomelib_ns.namespace('light')
+LightState = light_ns.LightState
+LightColorValues = light_ns.LightColorValues
+MQTTJSONLightComponent = light_ns.MQTTJSONLightComponent
+ToggleAction = light_ns.ToggleAction
+TurnOffAction = light_ns.TurnOffAction
+TurnOnAction = light_ns.TurnOnAction
+MakeLight = Application.MakeLight
+RandomLightEffect = light_ns.RandomLightEffect
+LambdaLightEffect = light_ns.LambdaLightEffect
+StrobeLightEffect = light_ns.StrobeLightEffect
+StrobeLightEffectColor = light_ns.StrobeLightEffectColor
+FlickerLightEffect = light_ns.FlickerLightEffect
+FastLEDLambdaLightEffect = light_ns.FastLEDLambdaLightEffect
+FastLEDRainbowLightEffect = light_ns.FastLEDRainbowLightEffect
+FastLEDColorWipeEffect = light_ns.FastLEDColorWipeEffect
+FastLEDColorWipeEffectColor = light_ns.FastLEDColorWipeEffectColor
+FastLEDScanEffect = light_ns.FastLEDScanEffect
+FastLEDScanEffectColor = light_ns.FastLEDScanEffectColor
+FastLEDTwinkleEffect = light_ns.FastLEDTwinkleEffect
+FastLEDRandomTwinkleEffect = light_ns.FastLEDRandomTwinkleEffect
+FastLEDFireworksEffect = light_ns.FastLEDFireworksEffect
+FastLEDFlickerEffect = light_ns.FastLEDFlickerEffect
+FastLEDLightOutputComponent = light_ns.FastLEDLightOutputComponent
+
+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:
+        lambda_ = None
+        args = [(RawExpression('FastLEDLightOutputComponent &'), '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(None),
+    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(None),
+    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(None),
+    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

esphomeyaml/components/light/binary.py

@@ -1,19 +1,21 @@
-
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import light
-from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_OUTPUT
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT, CONF_EFFECTS
 from esphomeyaml.helpers import App, get_variable, variable
 
-PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('binary_light'): cv.register_variable_id,
-    vol.Required(CONF_OUTPUT): cv.variable_id,
-})
+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(None),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.BINARY_EFFECTS),
+}))
 
 
 def to_code(config):
-    output = get_variable(config[CONF_OUTPUT])
+    output = None
+    for output in get_variable(config[CONF_OUTPUT]):
+        yield
     rhs = App.make_binary_light(config[CONF_NAME], output)
-    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
-    light.setup_mqtt_light_component(light_struct.Pmqtt, config)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)

esphomeyaml/components/light/cwww.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light
+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
+
+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(None),
+    vol.Required(CONF_WARM_WHITE): cv.use_variable_id(None),
+    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),
+}), 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)

esphomeyaml/components/light/fastled_clockless.py

@@ -0,0 +1,104 @@
+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
+
+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.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),
+}), 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:
+        power_supply = None
+        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)
+
+
+BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'

esphomeyaml/components/light/fastled_spi.py

@@ -0,0 +1,84 @@
+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
+
+CHIPSETS = [
+    'LPD8806',
+    'WS2801',
+    'WS2803',
+    'SM16716',
+    'P9813',
+    'APA102',
+    'SK9822',
+    'DOTSTAR',
+]
+
+RGB_ORDERS = [
+    'RGB',
+    'RBG',
+    'GRB',
+    'GBR',
+    'BRG',
+    'BGR',
+]
+
+MakeFastLEDLight = Application.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),
+}))
+
+
+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:
+        power_supply = None
+        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)
+
+
+BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'

esphomeyaml/components/light/monochromatic.py

@@ -2,22 +2,23 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import light
-from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_ID, \
-    CONF_NAME, CONF_OUTPUT
-from esphomeyaml.helpers import App, add, get_variable, variable
+from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
+    CONF_NAME, CONF_OUTPUT, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, 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(None),
     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),
+}))
 
 
 def to_code(config):
-    output = get_variable(config[CONF_OUTPUT])
+    output = None
+    for output in get_variable(config[CONF_OUTPUT]):
+        yield
     rhs = App.make_monochromatic_light(config[CONF_NAME], output)
-    light_struct = variable('Application::LightStruct', config[CONF_ID], rhs)
-    if CONF_GAMMA_CORRECT in config:
-        add(light_struct.Poutput.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
-    light.setup_mqtt_light_component(light_struct.Pmqtt, config)
+    light_struct = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)

esphomeyaml/components/light/rgb.py

@@ -3,25 +3,30 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import light
 from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_GREEN, CONF_ID, CONF_NAME, CONF_RED
-from esphomeyaml.helpers import App, add, get_variable, variable
+    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, variable
 
-PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('rgb_light'): cv.register_variable_id,
-    vol.Required(CONF_RED): cv.variable_id,
-    vol.Required(CONF_GREEN): cv.variable_id,
-    vol.Required(CONF_BLUE): cv.variable_id,
+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(None),
+    vol.Required(CONF_GREEN): cv.use_variable_id(None),
+    vol.Required(CONF_BLUE): cv.use_variable_id(None),
     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),
+}))
 
 
 def to_code(config):
-    red = get_variable(config[CONF_RED])
-    green = get_variable(config[CONF_GREEN])
-    blue = get_variable(config[CONF_BLUE])
+    red = None
+    for red in get_variable(config[CONF_RED]):
+        yield
+    green = None
+    for green in get_variable(config[CONF_GREEN]):
+        yield
+    blue = None
+    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)

esphomeyaml/components/light/rgbw.py

@@ -3,27 +3,34 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import light
 from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_GREEN, CONF_ID, CONF_NAME, CONF_RED, CONF_WHITE
-from esphomeyaml.helpers import App, get_variable, variable, add
+    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_WHITE, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, variable
 
-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(None),
+    vol.Required(CONF_GREEN): cv.use_variable_id(None),
+    vol.Required(CONF_BLUE): cv.use_variable_id(None),
+    vol.Required(CONF_WHITE): cv.use_variable_id(None),
     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),
+}))
 
 
 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])
+    red = None
+    for red in get_variable(config[CONF_RED]):
+        yield
+    green = None
+    for green in get_variable(config[CONF_GREEN]):
+        yield
+    blue = None
+    for blue in get_variable(config[CONF_BLUE]):
+        yield
+    white = None
+    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)

esphomeyaml/components/light/rgbww.py

@@ -0,0 +1,62 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import light
+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
+
+
+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(None),
+    vol.Required(CONF_GREEN): cv.use_variable_id(None),
+    vol.Required(CONF_BLUE): cv.use_variable_id(None),
+    vol.Required(CONF_COLD_WHITE): cv.use_variable_id(None),
+    vol.Required(CONF_WARM_WHITE): cv.use_variable_id(None),
+    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),
+}), 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)

esphomeyaml/components/logger.py

@@ -1,60 +1,128 @@
+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, TemplateArguments, add, esphomelib_ns, global_ns, \
+    process_lambda, RawExpression, statement
 
-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.LogComponent
+
+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,32 +1,65 @@
+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
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, RawExpression, \
+    StructInitializer, TemplateArguments, add, esphomelib_ns, optional, std_string, templatable, \
+    uint8, bool_, JsonObjectRef, process_lambda, JsonObjectConstRef
 
-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.MQTTMessage
+MQTTClientComponent = mqtt_ns.MQTTClientComponent
+MQTTPublishAction = mqtt_ns.MQTTPublishAction
+MQTTPublishJsonAction = mqtt_ns.MQTTPublishJsonAction
+MQTTMessageTrigger = mqtt_ns.MQTTMessageTrigger
+MQTTJsonMessageTrigger = mqtt_ns.MQTTJsonMessageTrigger
+
 
 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:
+        raise vol.Invalid(u"Broker cannot be empty")
     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,
@@ -35,19 +68,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])
     )
@@ -57,18 +108,134 @@ 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

esphomeyaml/components/ota.py

@@ -1,18 +1,20 @@
-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
 
 _LOGGER = logging.getLogger(__name__)
 
-CONFIG_SCHEMA = cv.ID_SCHEMA.extend({
-    cv.GenerateID(CONF_OTA): cv.register_variable_id,
+OTAComponent = esphomelib_ns.OTAComponent
+
+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,
@@ -22,10 +24,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 +36,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,103 @@
-
 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, bool_
 
 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')
+TurnOffAction = output_ns.TurnOffAction
+TurnOnAction = output_ns.TurnOnAction
+SetLevelAction = output_ns.SetLevelAction
+
+
+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):
+    for _ in setup_output_platform_(obj, config, skip_power_supply):
+        yield
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'
+
+
+CONF_OUTPUT_TURN_ON = 'output.turn_on'
+OUTPUT_TURN_OFF_ACTION = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(None),
+})
+
+
+@ACTION_REGISTRY.register(CONF_OUTPUT_TURN_ON, OUTPUT_TURN_OFF_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_off_action(template_arg)
+    type = TurnOffAction.template(arg_type)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_OUTPUT_TURN_OFF = 'output.turn_off'
+OUTPUT_TURN_ON_ACTION = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(None)
+})
+
+
+@ACTION_REGISTRY.register(CONF_OUTPUT_TURN_OFF, OUTPUT_TURN_ON_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_on_action(template_arg)
+    type = TurnOnAction.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(None),
+    vol.Required(CONF_LEVEL): 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, bool_):
+        yield None
+    add(action.set_level(template_))
+    yield action

esphomeyaml/components/output/esp8266_pwm.py

@@ -1,24 +1,36 @@
 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, \
-    ESP_PLATFORM_ESP8266
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_PIN, ESP_PLATFORM_ESP8266
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin, get_gpio_pin_number
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
 
-PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+
+def valid_pwm_pin(value):
+    if value[CONF_NUMBER] > 16:
+        raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
+    return value
+
+
+ESP8266PWMOutput = output.output_ns.ESP8266PWMOutput
+
+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),
 })
 
 
 def to_code(config):
-    if get_gpio_pin_number(config[CONF_PIN]) >= 16:
-        # Too difficult to do in config validation
-        raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    pin = None
+    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)
     output.setup_output_platform(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP8266_PWM_OUTPUT'

esphomeyaml/components/output/gpio.py

@@ -1,17 +1,26 @@
 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
 
-PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+GPIOBinaryOutputComponent = output.output_ns.GPIOBinaryOutputComponent
+
+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,
 })
 
 
 def to_code(config):
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    pin = None
+    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)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_OUTPUT'

esphomeyaml/components/output/ledc.py

@@ -15,12 +15,15 @@ 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.LEDCOutputComponent
+
+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))
@@ -32,7 +35,10 @@ def to_code(config):
     if frequency is None and CONF_BIT_DEPTH in config:
         frequency = 1000
     rhs = App.make_ledc_output(config[CONF_PIN], frequency, config.get(CONF_BIT_DEPTH))
-    ledc = Pvariable('output::LEDCOutputComponent', config[CONF_ID], rhs)
+    ledc = Pvariable(config[CONF_ID], rhs)
     if CONF_CHANNEL in config:
         add(ledc.set_channel(config[CONF_CHANNEL]))
     output.setup_output_platform(ledc, config)
+
+
+BUILD_FLAGS = '-DUSE_LEDC_OUTPUT'

esphomeyaml/components/output/pca9685.py

@@ -2,24 +2,33 @@ 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.Channel
+
+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
+    pca9685 = None
+    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,21 +1,24 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import output
 from esphomeyaml.const import CONF_ADDRESS, CONF_FREQUENCY, CONF_ID, CONF_PHASE_BALANCER
-from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, RawExpression, add
+from esphomeyaml.helpers import App, HexIntLiteral, Pvariable, add
 
 DEPENDENCIES = ['i2c']
 
-PHASE_BALANCERS = ['None', 'Linear', 'Weaved']
+PCA9685OutputComponent = output.output_ns.namespace('PCA9685OutputComponent')
 
-PCA9685_COMPONENT_TYPE = 'output::PCA9685OutputComponent'
+PHASE_BALANCER_MESSAGE = ("The phase_balancer option has been removed in version 1.5.0. "
+                          "esphomelib will now automatically choose a suitable phase balancer.")
 
 PCA9685_SCHEMA = vol.Schema({
-    cv.GenerateID('pca9685'): cv.register_variable_id,
+    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),
 })
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCA9685_SCHEMA])
@@ -24,10 +27,9 @@ CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCA9685_SCHEMA])
 def to_code(config):
     for conf in config:
         rhs = App.make_pca9685_component(conf.get(CONF_FREQUENCY))
-        pca9685 = Pvariable(PCA9685_COMPONENT_TYPE, conf[CONF_ID], rhs)
+        pca9685 = Pvariable(conf[CONF_ID], rhs)
         if CONF_ADDRESS in conf:
             add(pca9685.set_address(HexIntLiteral(conf[CONF_ADDRESS])))
-        if CONF_PHASE_BALANCER in conf:
-            phase_balancer = RawExpression(u'PCA9685_PhaseBalancer_{}'.format(
-                conf[CONF_PHASE_BALANCER]))
-            add(pca9685.set_phase_balancer(phase_balancer))
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphomeyaml/components/pcf8574.py

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

esphomeyaml/components/pn532.py

@@ -0,0 +1,43 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins, automation
+from esphomeyaml.components import binary_sensor
+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
+
+DEPENDENCIES = ['spi']
+
+PN532Component = binary_sensor.binary_sensor_ns.PN532Component
+PN532Trigger = binary_sensor.binary_sensor_ns.PN532Trigger
+
+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),
+    }),
+})])
+
+
+def to_code(config):
+    for conf in config:
+        spi = None
+        for spi in get_variable(conf[CONF_SPI_ID]):
+            yield
+        cs = None
+        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_)
+
+
+BUILD_FLAGS = '-DUSE_PN532'

esphomeyaml/components/power_supply.py

@@ -3,12 +3,15 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, add, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, gpio_output_pin_expression
 
-POWER_SUPPLY_SCHEMA = cv.REQUIRED_ID_SCHEMA.extend({
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period,
-    vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period,
+PowerSupplyComponent = esphomelib_ns.PowerSupplyComponent
+
+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,
 })
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [POWER_SUPPLY_SCHEMA])
@@ -16,10 +19,15 @@ 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])
+        pin = None
+        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]))
+
+
+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
+from esphomeyaml.components.uart import UARTComponent
+from esphomeyaml.const import CONF_ID, CONF_UART_ID
+from esphomeyaml.helpers import App, Pvariable, get_variable
+
+DEPENDENCIES = ['uart']
+
+RDM6300Component = binary_sensor.binary_sensor_ns.RDM6300Component
+
+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(UARTComponent),
+})])
+
+
+def to_code(config):
+    for conf in config:
+        uart = None
+        for uart in get_variable(conf[CONF_UART_ID]):
+            yield
+        rhs = App.make_rdm6300_component(uart)
+        Pvariable(conf[CONF_ID], rhs)
+
+
+BUILD_FLAGS = '-DUSE_RDM6300'

esphomeyaml/components/remote_receiver.py

@@ -0,0 +1,64 @@
+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
+
+remote_ns = esphomelib_ns.namespace('remote')
+
+RemoteReceiverComponent = remote_ns.RemoteReceiverComponent
+
+DUMPERS = {
+    'lg': remote_ns.LGDumper,
+    'nec': remote_ns.NECDumper,
+    'panasonic': remote_ns.PanasonicDumper,
+    'raw': remote_ns.RawDumper,
+    'samsung': remote_ns.SamsungDumper,
+    'sony': remote_ns.SonyDumper,
+    'rc_switch': remote_ns.RCSwitchDumper,
+}
+
+
+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,
+})])
+
+
+def to_code(config):
+    for conf in config:
+        pin = None
+        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]))
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_RECEIVER'

esphomeyaml/components/remote_transmitter.py

@@ -0,0 +1,116 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+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, Pvariable, add, esphomelib_ns, gpio_output_pin_expression
+
+remote_ns = esphomelib_ns.namespace('remote')
+
+RemoteTransmitterComponent = remote_ns.RemoteTransmitterComponent
+RCSwitchProtocol = remote_ns.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)),
+})])
+
+
+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:
+        pin = None
+        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]))
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_TRANSMITTER'

esphomeyaml/components/script.py

@@ -0,0 +1,36 @@
+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
+
+Script = esphomelib_ns.Script
+ScriptExecuteAction = esphomelib_ns.ScriptExecuteAction
+
+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,201 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_EXPIRE_AFTER, \
-    CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_ICON, \
-    CONF_ID, CONF_LAMBDA, CONF_MULTIPLY, CONF_NAME, CONF_OFFSET, CONF_SEND_EVERY, \
-    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
-from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
-    setup_mqtt_component
+from esphomeyaml import automation
+from esphomeyaml.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
+    CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, \
+    CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_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_SLIDING_WINDOW_MOVING_AVERAGE, \
+    CONF_THROTTLE, CONF_TRIGGER_ID, CONF_UNIQUE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, add, 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)
+
+
+FILTER_KEYS = [CONF_OFFSET, CONF_MULTIPLY, CONF_FILTER_OUT, CONF_FILTER_NAN,
+               CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_LAMBDA,
+               CONF_THROTTLE, CONF_DELTA, CONF_UNIQUE, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR]
+
+FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
+    vol.Optional(CONF_OFFSET): vol.Coerce(float),
+    vol.Optional(CONF_MULTIPLY): vol.Coerce(float),
+    vol.Optional(CONF_FILTER_OUT): vol.Coerce(float),
+    vol.Optional(CONF_FILTER_NAN): None,
+    vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.Schema({
+        vol.Required(CONF_WINDOW_SIZE): cv.positive_not_null_int,
+        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+    }),
+    vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
+        vol.Required(CONF_ALPHA): cv.positive_float,
+        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+    }),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_THROTTLE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DELTA): vol.Coerce(float),
+    vol.Optional(CONF_UNIQUE): None,
+    vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_DEBOUNCE): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_OR): validate_recursive_filter,
+}, cv.has_exactly_one_key(*FILTER_KEYS))])
+
+# pylint: disable=invalid-name
+sensor_ns = esphomelib_ns.namespace('sensor')
+Sensor = sensor_ns.Sensor
+MQTTSensorComponent = sensor_ns.MQTTSensorComponent
+OffsetFilter = sensor_ns.OffsetFilter
+MultiplyFilter = sensor_ns.MultiplyFilter
+FilterOutValueFilter = sensor_ns.FilterOutValueFilter
+FilterOutNANFilter = sensor_ns.FilterOutNANFilter
+SlidingWindowMovingAverageFilter = sensor_ns.SlidingWindowMovingAverageFilter
+ExponentialMovingAverageFilter = sensor_ns.ExponentialMovingAverageFilter
+LambdaFilter = sensor_ns.LambdaFilter
+ThrottleFilter = sensor_ns.ThrottleFilter
+DeltaFilter = sensor_ns.DeltaFilter
+OrFilter = sensor_ns.OrFilter
+HeartbeatFilter = sensor_ns.HeartbeatFilter
+DebounceFilter = sensor_ns.DebounceFilter
+UniqueFilter = sensor_ns.UniqueFilter
+
+SensorStateTrigger = sensor_ns.SensorStateTrigger
+SensorRawStateTrigger = sensor_ns.SensorRawStateTrigger
+ValueRangeTrigger = sensor_ns.ValueRangeTrigger
+
+SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSensorComponent),
+    cv.GenerateID(): cv.declare_variable_id(Sensor),
     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])
+    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'

esphomeyaml/components/sensor/adc.py

@@ -3,33 +3,52 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, \
+from esphomeyaml.const import CONF_ATTENUATION, CONF_MAKE_ID, CONF_NAME, CONF_PIN, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, RawExpression, add, variable
+from esphomeyaml.helpers import App, Application, add, global_ns, variable
 
 ATTENUATION_MODES = {
-    '0db': 'ADC_0db',
-    '2.5db': 'ADC_2_5db',
-    '6db': 'ADC_6db',
-    '11db': 'ADC_11db',
+    '0db': global_ns.ADC_0db,
+    '2.5db': global_ns.ADC_2_5db,
+    '6db': global_ns.ADC_6db,
+    '11db': global_ns.ADC_11db,
 }
 
-ATTENUATION_MODE_SCHEMA = vol.Any(*list(ATTENUATION_MODES.keys()))
 
-PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID('adc'): cv.register_variable_id,
-    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.MakeADCSensor
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    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,
+}))
 
 
 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(make.Padc, make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_ADC_SENSOR'
+
+
+def required_build_flags(config):
+    if config[CONF_PIN] == 'VCC':
+        return '-DUSE_ADC_SENSOR_VCC'
+    return None

esphomeyaml/components/sensor/ads1115.py

@@ -2,29 +2,31 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import get_variable, RawExpression
+from esphomeyaml.components.ads1115 import ADS1115Component
+from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import get_variable
 
 DEPENDENCIES = ['ads1115']
 
 MUX = {
-    'A0_A1': 'ADS1115_MUX_P0_N1',
-    'A0_A3': 'ADS1115_MUX_P0_N3',
-    'A1_A3': 'ADS1115_MUX_P1_N3',
-    'A2_A3': 'ADS1115_MUX_P2_N3',
-    'A0_GND': 'ADS1115_MUX_P0_NG',
-    'A1_GND': 'ADS1115_MUX_P1_NG',
-    'A2_GND': 'ADS1115_MUX_P2_NG',
-    'A3_GND': 'ADS1115_MUX_P3_NG',
+    'A0_A1': sensor.sensor_ns.ADS1115_MULTIPLEXER_P0_N1,
+    'A0_A3': sensor.sensor_ns.ADS1115_MULTIPLEXER_P0_N3,
+    'A1_A3': sensor.sensor_ns.ADS1115_MULTIPLEXER_P1_N3,
+    'A2_A3': sensor.sensor_ns.ADS1115_MULTIPLEXER_P2_N3,
+    'A0_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P0_NG,
+    'A1_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P1_NG,
+    'A2_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P2_NG,
+    'A3_GND': sensor.sensor_ns.ADS1115_MULTIPLEXER_P3_NG,
 }
 
 GAIN = {
-    '6.144': 'ADS1115_PGA_6P144',
-    '4.096': 'ADS1115_PGA_6P096',
-    '2.048': 'ADS1115_PGA_2P048',
-    '1.024': 'ADS1115_PGA_1P024',
-    '0.512': 'ADS1115_PGA_0P512',
-    '0.256': 'ADS1115_PGA_0P256',
+    '6.144': sensor.sensor_ns.ADS1115_GAIN_6P144,
+    '4.096': sensor.sensor_ns.ADS1115_GAIN_6P096,
+    '2.048': sensor.sensor_ns.ADS1115_GAIN_2P048,
+    '1.024': sensor.sensor_ns.ADS1115_GAIN_1P024,
+    '0.512': sensor.sensor_ns.ADS1115_GAIN_0P512,
+    '0.256': sensor.sensor_ns.ADS1115_GAIN_0P256,
 }
 
 
@@ -34,23 +36,32 @@ 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)
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    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'

esphomeyaml/components/sensor/bh1750.py

@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+BH1750_RESOLUTIONS = {
+    4.0: sensor.sensor_ns.BH1750_RESOLUTION_4P0_LX,
+    1.0: sensor.sensor_ns.BH1750_RESOLUTION_1P0_LX,
+    0.5: sensor.sensor_ns.BH1750_RESOLUTION_0P5_LX,
+}
+
+MakeBH1750Sensor = Application.MakeBH1750Sensor
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    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,
+}))
+
+
+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)
+
+
+BUILD_FLAGS = '-DUSE_BH1750'

esphomeyaml/components/sensor/ble_rssi.py

@@ -0,0 +1,23 @@
+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
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    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_rssi_sensor(config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
+    sensor.register_sensor(rhs, config)

esphomeyaml/components/sensor/bme280.py

@@ -0,0 +1,74 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_IIR_FILTER, CONF_MAKE_ID, \
+    CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, Application, add, variable
+
+DEPENDENCIES = ['i2c']
+
+OVERSAMPLING_OPTIONS = {
+    'NONE': sensor.sensor_ns.BME280_OVERSAMPLING_NONE,
+    '1X': sensor.sensor_ns.BME280_OVERSAMPLING_1X,
+    '2X': sensor.sensor_ns.BME280_OVERSAMPLING_2X,
+    '4X': sensor.sensor_ns.BME280_OVERSAMPLING_4X,
+    '8X': sensor.sensor_ns.BME280_OVERSAMPLING_8X,
+    '16X': sensor.sensor_ns.BME280_OVERSAMPLING_16X,
+}
+
+IIR_FILTER_OPTIONS = {
+    'OFF': sensor.sensor_ns.BME280_IIR_FILTER_OFF,
+    '2X': sensor.sensor_ns.BME280_IIR_FILTER_2X,
+    '4X': sensor.sensor_ns.BME280_IIR_FILTER_4X,
+    '8X': sensor.sensor_ns.BME280_IIR_FILTER_8X,
+    '16X': sensor.sensor_ns.BME280_IIR_FILTER_16X,
+}
+
+BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+MakeBME280Sensor = Application.MakeBME280Sensor
+
+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),
+    vol.Required(CONF_PRESSURE): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA),
+    vol.Required(CONF_HUMIDITY): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA),
+    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+})
+
+
+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])
+
+
+BUILD_FLAGS = '-DUSE_BME280'

esphomeyaml/components/sensor/bme680.py

@@ -0,0 +1,94 @@
+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
+
+DEPENDENCIES = ['i2c']
+
+OVERSAMPLING_OPTIONS = {
+    'NONE': sensor.sensor_ns.BME680_OVERSAMPLING_NONE,
+    '1X': sensor.sensor_ns.BME680_OVERSAMPLING_1X,
+    '2X': sensor.sensor_ns.BME680_OVERSAMPLING_2X,
+    '4X': sensor.sensor_ns.BME680_OVERSAMPLING_4X,
+    '8X': sensor.sensor_ns.BME680_OVERSAMPLING_8X,
+    '16X': sensor.sensor_ns.BME680_OVERSAMPLING_16X,
+}
+
+IIR_FILTER_OPTIONS = {
+    'OFF': sensor.sensor_ns.BME680_IIR_FILTER_OFF,
+    '1X': sensor.sensor_ns.BME680_IIR_FILTER_1X,
+    '3X': sensor.sensor_ns.BME680_IIR_FILTER_3X,
+    '7X': sensor.sensor_ns.BME680_IIR_FILTER_7X,
+    '15X': sensor.sensor_ns.BME680_IIR_FILTER_15X,
+    '31X': sensor.sensor_ns.BME680_IIR_FILTER_31X,
+    '63X': sensor.sensor_ns.BME680_IIR_FILTER_63X,
+    '127X': sensor.sensor_ns.BME680_IIR_FILTER_127X,
+}
+
+BME680_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+})
+
+MakeBME680Sensor = Application.MakeBME680Sensor
+
+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),
+    vol.Required(CONF_PRESSURE): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA),
+    vol.Required(CONF_HUMIDITY): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA),
+    vol.Required(CONF_GAS_RESISTANCE): cv.nameable(sensor.SENSOR_SCHEMA),
+    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,
+})
+
+
+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])
+
+
+BUILD_FLAGS = '-DUSE_BME680'

esphomeyaml/components/sensor/bmp085.py

@@ -2,19 +2,20 @@ 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
 
 DEPENDENCIES = ['i2c']
 
+MakeBMP085Sensor = Application.MakeBMP085Sensor
+
 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),
+    vol.Required(CONF_PRESSURE): cv.nameable(sensor.SENSOR_SCHEMA),
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
-    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 })
 
 
@@ -22,8 +23,14 @@ 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])
+
+
+BUILD_FLAGS = '-DUSE_BMP085_SENSOR'

esphomeyaml/components/sensor/bmp280.py

@@ -0,0 +1,67 @@
+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
+
+DEPENDENCIES = ['i2c']
+
+OVERSAMPLING_OPTIONS = {
+    'NONE': sensor.sensor_ns.BMP280_OVERSAMPLING_NONE,
+    '1X': sensor.sensor_ns.BMP280_OVERSAMPLING_1X,
+    '2X': sensor.sensor_ns.BMP280_OVERSAMPLING_2X,
+    '4X': sensor.sensor_ns.BMP280_OVERSAMPLING_4X,
+    '8X': sensor.sensor_ns.BMP280_OVERSAMPLING_8X,
+    '16X': sensor.sensor_ns.BMP280_OVERSAMPLING_16X,
+}
+
+IIR_FILTER_OPTIONS = {
+    'OFF': sensor.sensor_ns.BMP280_IIR_FILTER_OFF,
+    '2X': sensor.sensor_ns.BMP280_IIR_FILTER_2X,
+    '4X': sensor.sensor_ns.BMP280_IIR_FILTER_4X,
+    '8X': sensor.sensor_ns.BMP280_IIR_FILTER_8X,
+    '16X': sensor.sensor_ns.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.MakeBMP280Sensor
+
+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),
+    vol.Required(CONF_PRESSURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA),
+    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+})
+
+
+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])
+
+
+BUILD_FLAGS = '-DUSE_BMP280'