Bump version to v1.13.0b7

* Add uart.write action

* Lint

esphome/components/ct_clamp/ct_clamp_sensor.cpp

@@ -0,0 +1,67 @@
+#include "ct_clamp_sensor.h"
+
+#include "esphome/core/log.h"
+#include <cmath>
+
+namespace esphome {
+namespace ct_clamp {
+
+static const char *TAG = "ct_clamp";
+
+void CTClampSensor::dump_config() {
+  LOG_SENSOR("", "CT Clamp Sensor", this);
+  ESP_LOGCONFIG(TAG, "  Sample Duration: %.2fs", this->sample_duration_ / 1e3f);
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void CTClampSensor::update() {
+  // Update only starts the sampling phase, in loop() the actual sampling is happening.
+
+  // Request a high loop() execution interval during sampling phase.
+  this->high_freq_.start();
+
+  // Set timeout for ending sampling phase
+  this->set_timeout("read", this->sample_duration_, [this]() {
+    this->is_sampling_ = false;
+    this->high_freq_.stop();
+
+    if (this->num_samples_ == 0) {
+      // Shouldn't happen, but let's not crash if it does.
+      this->publish_state(NAN);
+      return;
+    }
+
+    float raw = this->sample_sum_ / this->num_samples_;
+    float irms = std::sqrt(raw);
+    ESP_LOGD(TAG, "'%s' - Raw Value: %.2fA", this->name_.c_str(), irms);
+    this->publish_state(irms);
+  });
+
+  // Set sampling values
+  this->is_sampling_ = true;
+  this->num_samples_ = 0;
+  this->sample_sum_ = 0.0f;
+}
+
+void CTClampSensor::loop() {
+  if (!this->is_sampling_)
+    return;
+
+  // Perform a single sample
+  float value = this->source_->sample();
+
+  // Adjust DC offset via low pass filter (exponential moving average)
+  const float alpha = 0.001f;
+  this->offset_ = this->offset_ * (1 - alpha) + value * alpha;
+
+  // Filtered value centered around the mid-point (0V)
+  float filtered = value - this->offset_;
+
+  // IRMS is sqrt(∑v_i²)
+  float sq = filtered * filtered;
+  this->sample_sum_ += sq;
+  this->num_samples_++;
+}
+
+}  // namespace ct_clamp
+}  // namespace esphome

esphome/components/ct_clamp/ct_clamp_sensor.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/esphal.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/voltage_sampler/voltage_sampler.h"
+
+namespace esphome {
+namespace ct_clamp {
+
+class CTClampSensor : public sensor::Sensor, public PollingComponent {
+ public:
+  void update() override;
+  void loop() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+  void set_sample_duration(uint32_t sample_duration) { sample_duration_ = sample_duration; }
+  void set_source(voltage_sampler::VoltageSampler *source) { source_ = source; }
+
+ protected:
+  /// High Frequency loop() requester used during sampling phase.
+  HighFrequencyLoopRequester high_freq_;
+
+  /// Duration in ms of the sampling phase.
+  uint32_t sample_duration_;
+  /// The sampling source to read values from.
+  voltage_sampler::VoltageSampler *source_;
+
+  /** The DC offset of the circuit.
+   *
+   * Diagram: https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino
+   *
+   * This is automatically calculated with an exponential moving average/digital low pass filter.
+   *
+   * 0.5 is a good initial approximation to start with for most ESP8266 setups.
+   */
+  float offset_ = 0.5f;
+
+  float sample_sum_ = 0.0f;
+  uint32_t num_samples_ = 0;
+  bool is_sampling_ = false;
+};
+
+}  // namespace ct_clamp
+}  // namespace esphome

esphome/components/ct_clamp/sensor.py

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, voltage_sampler
+from esphome.const import CONF_SENSOR, CONF_ID, ICON_FLASH, UNIT_AMPERE
+
+AUTO_LOAD = ['voltage_sampler']
+
+CONF_SAMPLE_DURATION = 'sample_duration'
+
+ct_clamp_ns = cg.esphome_ns.namespace('ct_clamp')
+CTClampSensor = ct_clamp_ns.class_('CTClampSensor', sensor.Sensor, cg.PollingComponent)
+
+CONFIG_SCHEMA = sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2).extend({
+    cv.GenerateID(): cv.declare_id(CTClampSensor),
+    cv.Required(CONF_SENSOR): cv.use_id(voltage_sampler.VoltageSampler),
+    cv.Optional(CONF_SAMPLE_DURATION, default='200ms'): cv.positive_time_period_milliseconds,
+}).extend(cv.polling_component_schema('60s'))
+
+
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    yield cg.register_component(var, config)
+    yield sensor.register_sensor(var, config)
+
+    sens = yield cg.get_variable(config[CONF_SENSOR])
+    cg.add(var.set_source(sens))
+    cg.add(var.set_sample_duration(config[CONF_SAMPLE_DURATION]))

esphome/components/cwww/cwww_light_output.h

@@ -20,7 +20,7 @@ class CWWWLightOutput : public light::LightOutput {
     traits.set_supports_rgb_white_value(false);
     traits.set_supports_color_temperature(true);
     traits.set_min_mireds(this->cold_white_temperature_);
-    traits.set_min_mireds(this->warm_white_temperature_);
+    traits.set_max_mireds(this->warm_white_temperature_);
     return traits;
   }
   void write_state(light::LightState *state) override {

esphome/components/light/automation.h

@@ -89,7 +89,7 @@ template<typename... Ts> class LightIsOnCondition : public Condition<Ts...> {
  protected:
   LightState *state_;
 };
-template<typename... Ts> class LightIsOffCondition : public Condition<LightState, Ts...> {
+template<typename... Ts> class LightIsOffCondition : public Condition<Ts...> {
  public:
   explicit LightIsOffCondition(LightState *state) : state_(state) {}
   bool check(Ts... x) override { return !this->state_->current_values.is_on(); }

esphome/components/light/automation.py

@@ -5,7 +5,7 @@ from esphome.const import CONF_ID, CONF_TRANSITION_LENGTH, CONF_STATE, CONF_FLAS
     CONF_EFFECT, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE, CONF_WHITE, \
     CONF_COLOR_TEMPERATURE, CONF_RANGE_FROM, CONF_RANGE_TO
 from .types import DimRelativeAction, ToggleAction, LightState, LightControlAction, \
-    AddressableLightState, AddressableSet
+    AddressableLightState, AddressableSet, LightIsOnCondition, LightIsOffCondition
 
 
 @automation.register_action('light.toggle', ToggleAction, automation.maybe_simple_id({
@@ -145,3 +145,16 @@ def light_addressable_set_to_code(config, action_id, template_arg, args):
         templ = yield cg.templatable(config[CONF_WHITE], args, cg.uint8, to_exp=rgbw_to_exp)
         cg.add(var.set_white(templ))
     yield var
+
+
+@automation.register_condition('light.is_on', LightIsOnCondition,
+                               automation.maybe_simple_id({
+                                   cv.Required(CONF_ID): cv.use_id(LightState),
+                               }))
+@automation.register_condition('light.is_off', LightIsOffCondition,
+                               automation.maybe_simple_id({
+                                   cv.Required(CONF_ID): cv.use_id(LightState),
+                               }))
+def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
+    paren = yield cg.get_variable(config[CONF_ID])
+    yield cg.new_Pvariable(condition_id, template_arg, paren)

esphome/components/light/types.py

@@ -16,6 +16,8 @@ ToggleAction = light_ns.class_('ToggleAction', automation.Action)
 LightControlAction = light_ns.class_('LightControlAction', automation.Action)
 DimRelativeAction = light_ns.class_('DimRelativeAction', automation.Action)
 AddressableSet = light_ns.class_('AddressableSet', automation.Action)
+LightIsOnCondition = light_ns.class_('LightIsOnCondition', automation.Condition)
+LightIsOffCondition = light_ns.class_('LightIsOffCondition', automation.Condition)
 
 # Effects
 LightEffect = light_ns.class_('LightEffect')

esphome/components/ntc/sensor.py

@@ -24,7 +24,7 @@ def validate_calibration_parameter(value):
         return cv.Schema({
             cv.Required(CONF_TEMPERATURE): cv.float_,
             cv.Required(CONF_VALUE): cv.float_,
-        })
+        })(value)
 
     value = cv.string(value)
     parts = value.split('->')

esphome/components/rgbww/light.py

@@ -37,4 +37,4 @@ def to_code(config):
 
     wwhite = yield cg.get_variable(config[CONF_WARM_WHITE])
     cg.add(var.set_warm_white(wwhite))
-    cg.add(var.set_warm_white_temperature(config[CONF_COLD_WHITE_COLOR_TEMPERATURE]))
+    cg.add(var.set_warm_white_temperature(config[CONF_WARM_WHITE_COLOR_TEMPERATURE]))

esphome/components/rgbww/rgbww_light_output.h

@@ -23,7 +23,7 @@ class RGBWWLightOutput : public light::LightOutput {
     traits.set_supports_rgb_white_value(true);
     traits.set_supports_color_temperature(true);
     traits.set_min_mireds(this->cold_white_temperature_);
-    traits.set_min_mireds(this->warm_white_temperature_);
+    traits.set_max_mireds(this->warm_white_temperature_);
     return traits;
   }
   void write_state(light::LightState *state) override {

esphome/components/tsl2561/sensor.py

@@ -32,7 +32,7 @@ TSL2561Sensor = tsl2561_ns.class_('TSL2561Sensor', sensor.Sensor, cg.PollingComp
 
 CONFIG_SCHEMA = sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1).extend({
     cv.GenerateID(): cv.declare_id(TSL2561Sensor),
-    cv.Optional(CONF_INTEGRATION_TIME, default=402): validate_integration_time,
+    cv.Optional(CONF_INTEGRATION_TIME, default='402ms'): validate_integration_time,
     cv.Optional(CONF_GAIN, default='1X'): cv.enum(GAINS, upper=True),
     cv.Optional(CONF_IS_CS_PACKAGE, default=False): cv.boolean,
 }).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x39))

esphome/components/uart/__init__.py

@@ -1,15 +1,27 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome import pins
-from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_RX_PIN, CONF_TX_PIN, CONF_UART_ID
+from esphome import pins, automation
+from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_RX_PIN, CONF_TX_PIN, CONF_UART_ID, CONF_DATA
 from esphome.core import CORE, coroutine
+from esphome.py_compat import text_type, binary_type, char_to_byte
 
 uart_ns = cg.esphome_ns.namespace('uart')
 UARTComponent = uart_ns.class_('UARTComponent', cg.Component)
 UARTDevice = uart_ns.class_('UARTDevice')
+UARTWriteAction = uart_ns.class_('UARTWriteAction', automation.Action)
 MULTI_CONF = True
 
 
+def validate_raw_data(value):
+    if isinstance(value, text_type):
+        return value.encode('utf-8')
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise cv.Invalid("data must either be a string wrapped in quotes or a list of bytes")
+
+
 def validate_rx_pin(value):
     value = pins.input_pin(value)
     if CORE.is_esp8266 and value >= 16:
@@ -51,3 +63,22 @@ def register_uart_device(var, config):
     """
     parent = yield cg.get_variable(config[CONF_UART_ID])
     cg.add(var.set_uart_parent(parent))
+
+
+@automation.register_action('uart.write', UARTWriteAction, cv.maybe_simple_value({
+    cv.GenerateID(): cv.use_id(UARTComponent),
+    cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
+}, key=CONF_DATA))
+def uart_write_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    yield cg.register_parented(var, config[CONF_ID])
+    data = config[CONF_DATA]
+    if isinstance(data, binary_type):
+        data = [char_to_byte(x) for x in data]
+
+    if cg.is_template(data):
+        templ = yield cg.templatable(data, args, cg.std_vector.template(cg.uint8))
+        cg.add(var.set_data_template(templ))
+    else:
+        cg.add(var.set_data_static(data))
+    yield var

esphome/components/uart/automation.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "uart.h"
+#include "esphome/core/automation.h"
+
+namespace esphome {
+namespace uart {
+
+template<typename... Ts> class UARTWriteAction : public Action<Ts...>, public Parented<UARTComponent> {
+ public:
+  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->data_func_ = func;
+    this->static_ = false;
+  }
+  void set_data_static(const std::vector<uint8_t> &data) {
+    this->data_static_ = data;
+    this->static_ = true;
+  }
+
+  void play(Ts... x) override {
+    if (this->static_) {
+      this->parent_->write_array(this->data_static_);
+    } else {
+      auto val = this->data_func_(x...);
+      this->parent_->write_array(val);
+    }
+  }
+
+ protected:
+  bool static_{false};
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  std::vector<uint8_t> data_static_{};
+};
+
+}  // namespace uart
+}  // namespace esphome

esphome/components/uart/switch/__init__.py

@@ -3,27 +3,17 @@ import esphome.config_validation as cv
 from esphome.components import switch, uart
 from esphome.const import CONF_DATA, CONF_ID, CONF_INVERTED
 from esphome.core import HexInt
-from esphome.py_compat import text_type, binary_type, char_to_byte
-from .. import uart_ns
+from esphome.py_compat import binary_type, char_to_byte
+from .. import uart_ns, validate_raw_data
 
 DEPENDENCIES = ['uart']
 
 UARTSwitch = uart_ns.class_('UARTSwitch', switch.Switch, uart.UARTDevice, cg.Component)
 
 
-def validate_data(value):
-    if isinstance(value, text_type):
-        return value.encode('utf-8')
-    if isinstance(value, str):
-        return value
-    if isinstance(value, list):
-        return cv.Schema([cv.hex_uint8_t])(value)
-    raise cv.Invalid("data must either be a string wrapped in quotes or a list of bytes")
-
-
 CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend({
     cv.GenerateID(): cv.declare_id(UARTSwitch),
-    cv.Required(CONF_DATA): validate_data,
+    cv.Required(CONF_DATA): validate_raw_data,
     cv.Optional(CONF_INVERTED): cv.invalid("UART switches do not support inverted mode!"),
 }).extend(uart.UART_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/uart/uart.h

@@ -49,6 +49,7 @@ class UARTComponent : public Component, public Stream {
   void write_byte(uint8_t data);
 
   void write_array(const uint8_t *data, size_t len);
+  void write_array(const std::vector<uint8_t> &data) { this->write_array(&data[0], data.size()); }
 
   void write_str(const char *str);
 
@@ -97,6 +98,7 @@ class UARTDevice : public Stream {
   void write_byte(uint8_t data) { this->parent_->write_byte(data); }
 
   void write_array(const uint8_t *data, size_t len) { this->parent_->write_array(data, len); }
+  void write_array(const std::vector<uint8_t> &data) { this->parent_->write_array(data); }
 
   void write_str(const char *str) { this->parent_->write_str(str); }
 

esphome/config.py

@@ -612,9 +612,9 @@ def _format_vol_invalid(ex, config):
         else:
             message += u'[{}] is an invalid option for [{}]. Please check the indentation.'.format(
                 ex.path[-1], paren)
-    elif u'extra keys not allowed' in ex.error_message:
+    elif u'extra keys not allowed' in text_type(ex):
         message += u'[{}] is an invalid option for [{}].'.format(ex.path[-1], paren)
-    elif u'required key not provided' in ex.error_message:
+    elif u'required key not provided' in text_type(ex):
         message += u"'{}' is a required option for [{}].".format(ex.path[-1], paren)
     else:
         message += humanize_error(config, ex)

esphome/config_validation.py

@@ -20,7 +20,7 @@ from esphome.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY,
 from esphome.core import CORE, HexInt, IPAddress, Lambda, TimePeriod, TimePeriodMicroseconds, \
     TimePeriodMilliseconds, TimePeriodSeconds, TimePeriodMinutes
 from esphome.helpers import list_starts_with
-from esphome.py_compat import integer_types, string_types, text_type, IS_PY2
+from esphome.py_compat import integer_types, string_types, text_type, IS_PY2, decode_text
 from esphome.voluptuous_schema import _Schema
 
 _LOGGER = logging.getLogger(__name__)
@@ -61,6 +61,7 @@ RESERVED_IDS = [
     'App', 'pinMode', 'delay', 'delayMicroseconds', 'digitalRead', 'digitalWrite', 'INPUT',
     'OUTPUT',
     'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'int8_t', 'int16_t', 'int32_t', 'int64_t',
+    'close', 'pause', 'sleep', 'open',
 ]
 
 
@@ -616,9 +617,9 @@ if IS_PY2:
     # Override voluptuous invalid to unicode for py2
     def _vol_invalid_unicode(self):
         path = u' @ data[%s]' % u']['.join(map(repr, self.path)) \
-            if self.path else ''
+            if self.path else u''
         # pylint: disable=no-member
-        output = self.message
+        output = decode_text(self.message)
         if self.error_type:
             output += u' for ' + self.error_type
         return output + path
@@ -1209,13 +1210,14 @@ def validate_registry(name, registry):
     return ensure_list(validate_registry_entry(name, registry))
 
 
-def maybe_simple_value(*validators):
+def maybe_simple_value(*validators, **kwargs):
+    key = kwargs.pop('key', CONF_VALUE)
     validator = All(*validators)
 
     def validate(value):
-        if isinstance(value, dict) and CONF_VALUE in value:
+        if isinstance(value, dict) and key in value:
             return validator(value)
-        return validator({CONF_VALUE: value})
+        return validator({key: value})
 
     return validate
 

esphome/const.py

@@ -3,7 +3,7 @@
 
 MAJOR_VERSION = 1
 MINOR_VERSION = 13
-PATCH_VERSION = '0b4'
+PATCH_VERSION = '0b7'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
 

esphome/core/application.cpp

@@ -66,6 +66,42 @@ void Application::dump_config() {
     component->dump_config();
   }
 }
+void Application::loop() {
+  uint32_t new_app_state = 0;
+  const uint32_t start = millis();
+  for (Component *component : this->components_) {
+    if (!component->is_failed()) {
+      component->call_loop();
+    }
+    new_app_state |= component->get_component_state();
+    this->app_state_ |= new_app_state;
+    this->feed_wdt();
+  }
+  this->app_state_ = new_app_state;
+  const uint32_t end = millis();
+  if (end - start > 200) {
+    ESP_LOGV(TAG, "A component took a long time in a loop() cycle (%.1f s).", (end - start) / 1e3f);
+    ESP_LOGV(TAG, "Components should block for at most 20-30ms in loop().");
+    ESP_LOGV(TAG, "This will become a warning soon.");
+  }
+
+  const uint32_t now = millis();
+
+  if (HighFrequencyLoopRequester::is_high_frequency()) {
+    yield();
+  } else {
+    uint32_t delay_time = this->loop_interval_;
+    if (now - this->last_loop_ < this->loop_interval_)
+      delay_time = this->loop_interval_ - (now - this->last_loop_);
+    delay(delay_time);
+  }
+  this->last_loop_ = now;
+
+  if (this->dump_config_scheduled_) {
+    this->dump_config();
+    this->dump_config_scheduled_ = false;
+  }
+}
 
 void ICACHE_RAM_ATTR HOT Application::feed_wdt() {
   static uint32_t LAST_FEED = 0;

esphome/core/application.h

@@ -87,34 +87,7 @@ class Application {
   void setup();
 
   /// Make a loop iteration. Call this in your loop() function.
-  void loop() {
-    uint32_t new_app_state = 0;
-    for (Component *component : this->components_) {
-      if (!component->is_failed()) {
-        component->call_loop();
-      }
-      new_app_state |= component->get_component_state();
-      this->app_state_ |= new_app_state;
-      this->feed_wdt();
-    }
-    this->app_state_ = new_app_state;
-
-    const uint32_t now = millis();
-    if (HighFrequencyLoopRequester::is_high_frequency()) {
-      yield();
-    } else {
-      uint32_t delay_time = this->loop_interval_;
-      if (now - this->last_loop_ < this->loop_interval_)
-        delay_time = this->loop_interval_ - (now - this->last_loop_);
-      delay(delay_time);
-    }
-    this->last_loop_ = now;
-
-    if (this->dump_config_scheduled_) {
-      this->dump_config();
-      this->dump_config_scheduled_ = false;
-    }
-  }
+  void loop();
 
   /// Get the name of this Application set by set_name().
   const std::string &get_name() const { return this->name_; }

esphome/core_config.py

@@ -13,6 +13,7 @@ from esphome.const import ARDUINO_VERSION_ESP32_DEV, ARDUINO_VERSION_ESP8266_DEV
     CONF_ESP8266_RESTORE_FROM_FLASH, __version__, ARDUINO_VERSION_ESP8266_2_3_0, \
     ARDUINO_VERSION_ESP8266_2_5_0, ARDUINO_VERSION_ESP8266_2_5_1, ARDUINO_VERSION_ESP8266_2_5_2
 from esphome.core import CORE, coroutine_with_priority
+from esphome.helpers import copy_file_if_changed, walk_files
 from esphome.pins import ESP8266_FLASH_SIZES, ESP8266_LD_SCRIPTS
 
 _LOGGER = logging.getLogger(__name__)
@@ -59,6 +60,7 @@ PLATFORMIO_ESP8266_LUT = {
 PLATFORMIO_ESP32_LUT = {
     '1.0.0': 'espressif32@1.4.0',
     '1.0.1': 'espressif32@1.6.0',
+    '1.0.2': 'espressif32@1.8.0',
     'RECOMMENDED': 'espressif32@1.6.0',
     'LATEST': 'espressif32',
     'DEV': ARDUINO_VERSION_ESP32_DEV,
@@ -91,6 +93,22 @@ def default_build_path():
     return CORE.name
 
 
+VALID_INCLUDE_EXTS = {'.h', '.hpp', '.tcc', '.ino', '.cpp', '.c'}
+
+
+def valid_include(value):
+    try:
+        return cv.directory(value)
+    except cv.Invalid:
+        pass
+    value = cv.file_(value)
+    _, ext = os.path.splitext(value)
+    if ext not in VALID_INCLUDE_EXTS:
+        raise cv.Invalid(u"Include has invalid file extension {} - valid extensions are {}"
+                         u"".format(ext, ', '.join(VALID_INCLUDE_EXTS)))
+    return value
+
+
 CONFIG_SCHEMA = cv.Schema({
     cv.Required(CONF_NAME): cv.valid_name,
     cv.Required(CONF_PLATFORM): cv.one_of('ESP8266', 'ESP32', upper=True),
@@ -115,7 +133,7 @@ CONFIG_SCHEMA = cv.Schema({
     cv.Optional(CONF_ON_LOOP): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoopTrigger),
     }),
-    cv.Optional(CONF_INCLUDES, default=[]): cv.ensure_list(cv.file_),
+    cv.Optional(CONF_INCLUDES, default=[]): cv.ensure_list(valid_include),
     cv.Optional(CONF_LIBRARIES, default=[]): cv.ensure_list(cv.string_strict),
 
     cv.Optional('esphome_core_version'): cv.invalid("The esphome_core_version option has been "
@@ -153,13 +171,31 @@ def preload_core_config(config):
     CORE.build_path = CORE.relative_config_path(out2[CONF_BUILD_PATH])
 
 
+def include_file(path, basename):
+    parts = basename.split(os.path.sep)
+    dst = CORE.relative_src_path(*parts)
+    copy_file_if_changed(path, dst)
+
+    _, ext = os.path.splitext(path)
+    if ext in ['.h', '.hpp', '.tcc']:
+        # Header, add include statement
+        cg.add_global(cg.RawStatement(u'#include "{}"'.format(basename)))
+
+
 @coroutine_with_priority(-1000.0)
 def add_includes(includes):
     # Add includes at the very end, so that the included files can access global variables
     for include in includes:
         path = CORE.relative_config_path(include)
-        res = os.path.relpath(path, CORE.relative_build_path('src')).replace(os.path.sep, '/')
-        cg.add_global(cg.RawStatement(u'#include "{}"'.format(res)))
+        if os.path.isdir(path):
+            # Directory, copy tree
+            for p in walk_files(path):
+                basename = os.path.relpath(p, os.path.dirname(path))
+                include_file(p, basename)
+        else:
+            # Copy file
+            basename = os.path.basename(path)
+            include_file(path, basename)
 
 
 @coroutine_with_priority(100.0)

esphome/dashboard/static/esphome.js

@@ -607,9 +607,9 @@ const startAceWebsocket = () => {
         editor.session.setAnnotations(arr);
 
         if(arr.length) {
-          saveUploadButton.classList.add('disabled');
+          editorUploadButton.classList.add('disabled');
         } else {
-          saveUploadButton.classList.remove('disabled');
+          editorUploadButton.classList.remove('disabled');
         }
 
         aceValidationRunning = false;
@@ -646,7 +646,7 @@ editor.session.setOption('tabSize', 2);
 editor.session.setOption('useWorker', false);
 
 const saveButton = editModalElem.querySelector(".save-button");
-const saveUploadButton = editModalElem.querySelector(".save-upload-button");
+const editorUploadButton = editModalElem.querySelector(".editor-upload-button");
 const saveEditor = () => {
   fetch(`./edit?configuration=${activeEditorConfig}`, {
       credentials: "same-origin",
@@ -698,14 +698,14 @@ setInterval(() => {
 }, 100);
 
 saveButton.addEventListener('click', saveEditor);
-saveUploadButton.addEventListener('click', saveEditor);
+editorUploadButton.addEventListener('click', saveEditor);
 
 document.querySelectorAll(".action-edit").forEach((btn) => {
   btn.addEventListener('click', (e) => {
     activeEditorConfig = e.target.getAttribute('data-node');
     const modalInstance = M.Modal.getInstance(editModalElem);
     const filenameField = editModalElem.querySelector('.filename');
-    editModalElem.querySelector(".save-upload-button").setAttribute('data-node', activeEditorConfig);
+    editorUploadButton.setAttribute('data-node', activeEditorConfig);
     filenameField.innerHTML = activeEditorConfig;
 
     fetch(`./edit?configuration=${activeEditorConfig}`, {credentials: "same-origin"})

esphome/dashboard/templates/index.html

@@ -440,7 +440,7 @@
   </div>
   <div class="modal-footer">
     <a class="waves-effect waves-green btn-flat save-button">Save</a>
-    <a class="modal-close waves-effect waves-green btn-flat action-upload save-upload-button">Save &amp; Upload</a>
+    <a class="modal-close waves-effect waves-green btn-flat action-upload editor-upload-button">Upload</a>
     <a class="modal-close waves-effect waves-green btn-flat">Close</a>
   </div>
 </div>

esphome/helpers.py

@@ -157,6 +157,12 @@ def copy_file_if_changed(src, dst):
     write_file(dst, src_text)
 
 
+def walk_files(path):
+    for root, _, files in os.walk(path):
+        for name in files:
+            yield os.path.join(root, name)
+
+
 def read_file(path):
     try:
         with codecs.open(path, 'r', encoding='utf-8') as f_handle:

esphome/writer.py

@@ -8,7 +8,7 @@ from esphome.config import iter_components
 from esphome.const import CONF_BOARD_FLASH_MODE, CONF_ESPHOME, CONF_PLATFORMIO_OPTIONS, \
     HEADER_FILE_EXTENSIONS, SOURCE_FILE_EXTENSIONS
 from esphome.core import CORE, EsphomeError
-from esphome.helpers import mkdir_p, read_file, write_file_if_changed
+from esphome.helpers import mkdir_p, read_file, write_file_if_changed, walk_files
 from esphome.storage_json import StorageJSON, storage_path
 
 _LOGGER = logging.getLogger(__name__)
@@ -281,12 +281,6 @@ or use the custom_components folder.
 """
 
 
-def walk_files(path):
-    for root, _, files in os.walk(path):
-        for name in files:
-            yield os.path.join(root, name)
-
-
 def copy_src_tree():
     import filecmp
     import shutil

tests/test1.yaml

@@ -84,6 +84,8 @@ mqtt:
         condition:
           - wifi.connected:
           - mqtt.connected:
+          - light.is_on: kitchen
+          - light.is_off: kitchen
         then:
         - lambda: |-
             int data = x["my_data"];
@@ -103,6 +105,12 @@ mqtt:
         - light.control:
             id: living_room_lights
             brightness: !lambda 'return id(living_room_lights).current_values.get_brightness() + 0.5;'
+        - uart.write:
+            id: uart0
+            data: Hello World
+        - uart.write: [0x00, 0x20, 0x30]
+        - uart.write: !lambda |-
+            return {};
 
 i2c:
   sda: 21
@@ -120,6 +128,7 @@ uart:
   tx_pin: GPIO22
   rx_pin: GPIO23
   baud_rate: 115200
+  id: uart0
 
 ota:
   safe_mode: True

tests/test3.yaml

@@ -129,6 +129,19 @@ sensor:
       b_constant: 3950
       reference_resistance: 10k
       reference_temperature: 25°C
+  - platform: ntc
+    sensor: resist
+    name: NTC Sensor2
+    calibration:
+      - 10.0kOhm -> 25°C
+      - 27.219kOhm -> 0°C
+      - 14.674kOhm -> 15°C
+  - platform: ct_clamp
+    sensor: my_sensor
+    name: CT Clamp
+    sample_duration: 500ms
+    update_interval: 5s
+
   - platform: tcs34725
     red_channel:
       name: Red Channel