🏗 Merge C++ into python codebase (#504)

## Description:

Move esphome-core codebase into esphome (and a bunch of other refactors). See https://github.com/esphome/feature-requests/issues/97

Yes this is a shit ton of work and no there's no way to automate it :( But it will be worth it 👍

Progress:
- Core support (file copy etc): 80%
- Base Abstractions (light, switch): ~50%
- Integrations: ~10%
- Working? Yes, (but only with ported components).

Other refactors:
- Moves all codegen related stuff into a single class: `esphome.codegen` (imported as `cg`)
- Rework coroutine syntax
- Move from `component/platform.py` to `domain/component.py` structure as with HA
- Move all defaults out of C++ and into config validation.
- Remove `make_...` helpers from Application class. Reason: Merge conflicts with every single new integration.
- Pointer Variables are stored globally instead of locally in setup(). Reason: stack size limit.

Future work:
- Rework const.py - Move all `CONF_...` into a conf class (usage `conf.UPDATE_INTERVAL` vs `CONF_UPDATE_INTERVAL`). Reason: Less convoluted import block
- Enable loading from `custom_components` folder.

**Related issue (if applicable):** https://github.com/esphome/feature-requests/issues/97

**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>

## Checklist:
  - [ ] The code change is tested and works locally.
  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).

If user exposed functionality or configuration variables are added/changed:
  - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

esphome/components/pulse_counter/pulse_counter_sensor.cpp

@@ -0,0 +1,165 @@
+#include "pulse_counter_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace pulse_counter {
+
+static const char *TAG = "pulse_counter";
+
+const char *EDGE_MODE_TO_STRING[] = {"DISABLE", "INCREMENT", "DECREMENT"};
+
+#ifdef ARDUINO_ARCH_ESP8266
+void ICACHE_RAM_ATTR PulseCounterStorage::gpio_intr(PulseCounterStorage *arg) {
+  const uint32_t now = micros();
+  const bool discard = now - arg->last_pulse < arg->filter_us;
+  arg->last_pulse = now;
+  if (discard)
+    return;
+
+  PulseCounterCountMode mode = arg->isr_pin->digital_read() ? arg->rising_edge_mode : arg->falling_edge_mode;
+  switch (mode) {
+    case PULSE_COUNTER_DISABLE:
+      break;
+    case PULSE_COUNTER_INCREMENT:
+      arg->counter++;
+      break;
+    case PULSE_COUNTER_DECREMENT:
+      arg->counter--;
+      break;
+  }
+}
+bool PulseCounterStorage::pulse_counter_setup() {
+  this->isr_pin = this->pin->to_isr();
+  this->pin->attach_interrupt(PulseCounterStorage::gpio_intr, this, CHANGE);
+  return true;
+}
+pulse_counter_t PulseCounterStorage::read_raw_value() {
+  pulse_counter_t counter = this->counter;
+  pulse_counter_t ret = counter - this->last_value;
+  this->last_value = counter;
+  return ret;
+}
+#endif
+
+#ifdef ARDUINO_ARCH_ESP32
+bool PulseCounterStorage::pulse_counter_setup() {
+  this->pcnt_unit = next_pcnt_unit;
+  next_pcnt_unit = pcnt_unit_t(int(next_pcnt_unit) + 1);  // NOLINT
+
+  ESP_LOGCONFIG(TAG, "    PCNT Unit Number: %u", this->pcnt_unit);
+
+  pcnt_count_mode_t rising = PCNT_COUNT_DIS, falling = PCNT_COUNT_DIS;
+  switch (this->rising_edge_mode) {
+    case PULSE_COUNTER_DISABLE:
+      rising = PCNT_COUNT_DIS;
+      break;
+    case PULSE_COUNTER_INCREMENT:
+      rising = PCNT_COUNT_INC;
+      break;
+    case PULSE_COUNTER_DECREMENT:
+      rising = PCNT_COUNT_DEC;
+      break;
+  }
+  switch (this->falling_edge_mode) {
+    case PULSE_COUNTER_DISABLE:
+      falling = PCNT_COUNT_DIS;
+      break;
+    case PULSE_COUNTER_INCREMENT:
+      falling = PCNT_COUNT_INC;
+      break;
+    case PULSE_COUNTER_DECREMENT:
+      falling = PCNT_COUNT_DEC;
+      break;
+  }
+
+  pcnt_config_t pcnt_config = {
+      .pulse_gpio_num = this->pin->get_pin(),
+      .ctrl_gpio_num = PCNT_PIN_NOT_USED,
+      .lctrl_mode = PCNT_MODE_KEEP,
+      .hctrl_mode = PCNT_MODE_KEEP,
+      .pos_mode = rising,
+      .neg_mode = falling,
+      .counter_h_lim = 0,
+      .counter_l_lim = 0,
+      .unit = this->pcnt_unit,
+      .channel = PCNT_CHANNEL_0,
+  };
+  esp_err_t error = pcnt_unit_config(&pcnt_config);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Configuring Pulse Counter failed: %s", esp_err_to_name(error));
+    return false;
+  }
+
+  if (this->filter_us != 0) {
+    uint16_t filter_val = std::min(this->filter_us * 80u, 1023u);
+    ESP_LOGCONFIG(TAG, "    Filter Value: %uus (val=%u)", this->filter_us, filter_val);
+    error = pcnt_set_filter_value(this->pcnt_unit, filter_val);
+    if (error != ESP_OK) {
+      ESP_LOGE(TAG, "Setting filter value failed: %s", esp_err_to_name(error));
+      return false;
+    }
+    error = pcnt_filter_enable(this->pcnt_unit);
+    if (error != ESP_OK) {
+      ESP_LOGE(TAG, "Enabling filter failed: %s", esp_err_to_name(error));
+      return false;
+    }
+  }
+
+  error = pcnt_counter_pause(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Pausing pulse counter failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  error = pcnt_counter_clear(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Clearing pulse counter failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  error = pcnt_counter_resume(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Resuming pulse counter failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  return true;
+}
+pulse_counter_t PulseCounterStorage::read_raw_value() {
+  pulse_counter_t counter;
+  pcnt_get_counter_value(this->pcnt_unit, &counter);
+  pulse_counter_t ret = counter - this->last_value;
+  this->last_value = counter;
+  return ret;
+}
+#endif
+
+void PulseCounterSensor::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up pulse counter '%s'...", this->name_.c_str());
+  this->pin_->setup();
+  this->storage_.pin = this->pin_;
+  if (!this->storage_.pulse_counter_setup()) {
+    this->mark_failed();
+    return;
+  }
+}
+
+void PulseCounterSensor::dump_config() {
+  LOG_SENSOR("", "Pulse Counter", this);
+  LOG_PIN("  Pin: ", this->pin_);
+  ESP_LOGCONFIG(TAG, "  Rising Edge: %s", EDGE_MODE_TO_STRING[this->storage_.rising_edge_mode]);
+  ESP_LOGCONFIG(TAG, "  Falling Edge: %s", EDGE_MODE_TO_STRING[this->storage_.falling_edge_mode]);
+  ESP_LOGCONFIG(TAG, "  Filtering pulses shorter than %u µs", this->storage_.filter_us);
+}
+
+void PulseCounterSensor::update() {
+  pulse_counter_t raw = this->storage_.read_raw_value();
+  float value = (60000.0f * raw) / float(this->get_update_interval());  // per minute
+
+  ESP_LOGD(TAG, "'%s': Retrieved counter: %0.2f pulses/min", this->get_name().c_str(), value);
+  this->publish_state(value);
+}
+
+#ifdef ARDUINO_ARCH_ESP32
+pcnt_unit_t next_pcnt_unit = PCNT_UNIT_0;
+#endif
+
+}  // namespace pulse_counter
+}  // namespace esphome

esphome/components/pulse_counter/pulse_counter_sensor.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/esphal.h"
+#include "esphome/components/sensor/sensor.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+#include <driver/pcnt.h>
+#endif
+
+namespace esphome {
+namespace pulse_counter {
+
+enum PulseCounterCountMode {
+  PULSE_COUNTER_DISABLE = 0,
+  PULSE_COUNTER_INCREMENT,
+  PULSE_COUNTER_DECREMENT,
+};
+
+#ifdef ARDUINO_ARCH_ESP32
+using pulse_counter_t = int16_t;
+#endif
+#ifdef ARDUINO_ARCH_ESP8266
+using pulse_counter_t = int32_t;
+#endif
+
+struct PulseCounterStorage {
+  bool pulse_counter_setup();
+  pulse_counter_t read_raw_value();
+
+  static void gpio_intr(PulseCounterStorage *arg);
+
+#ifdef ARDUINO_ARCH_ESP8266
+  volatile pulse_counter_t counter{0};
+  volatile uint32_t last_pulse{0};
+#endif
+
+  GPIOPin *pin;
+#ifdef ARDUINO_ARCH_ESP32
+  pcnt_unit_t pcnt_unit;
+#endif
+#ifdef ARDUINO_ARCH_ESP8266
+  ISRInternalGPIOPin *isr_pin;
+#endif
+  PulseCounterCountMode rising_edge_mode{};
+  PulseCounterCountMode falling_edge_mode{};
+  uint32_t filter_us{};
+  pulse_counter_t last_value{0};
+};
+
+class PulseCounterSensor : public sensor::PollingSensorComponent {
+ public:
+  explicit PulseCounterSensor(const std::string &name, GPIOPin *pin, uint32_t update_interval,
+                              PulseCounterCountMode rising_edge_mode, PulseCounterCountMode falling_edge_mode,
+                              uint32_t filter_us)
+      : sensor::PollingSensorComponent(name, update_interval), pin_(pin) {
+    this->storage_.rising_edge_mode = rising_edge_mode;
+    this->storage_.falling_edge_mode = falling_edge_mode;
+    this->storage_.filter_us = filter_us;
+  }
+
+  /// Unit of measurement is "pulses/min".
+  void setup() override;
+  void update() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void dump_config() override;
+
+ protected:
+  GPIOPin *pin_;
+  PulseCounterStorage storage_;
+};
+
+#ifdef ARDUINO_ARCH_ESP32
+extern pcnt_unit_t next_pcnt_unit;
+#endif
+
+}  // namespace pulse_counter
+}  // namespace esphome

esphome/components/pulse_counter/sensor.py

@@ -0,0 +1,69 @@
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
+    CONF_NAME, CONF_PIN, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, CONF_NUMBER, \
+    CONF_ACCURACY_DECIMALS, CONF_ICON, CONF_UNIT_OF_MEASUREMENT, ICON_PULSE, UNIT_PULSES_PER_MINUTE
+from esphome.core import CORE
+
+pulse_counter_ns = cg.esphome_ns.namespace('pulse_counter')
+PulseCounterCountMode = pulse_counter_ns.enum('PulseCounterCountMode')
+COUNT_MODES = {
+    'DISABLE': PulseCounterCountMode.PULSE_COUNTER_DISABLE,
+    'INCREMENT': PulseCounterCountMode.PULSE_COUNTER_INCREMENT,
+    'DECREMENT': PulseCounterCountMode.PULSE_COUNTER_DECREMENT,
+}
+
+COUNT_MODE_SCHEMA = cv.one_of(*COUNT_MODES, upper=True)
+
+PulseCounterSensor = pulse_counter_ns.class_('PulseCounterSensor',
+                                             sensor.PollingSensorComponent)
+
+
+def validate_internal_filter(value):
+    value = cv.positive_time_period_microseconds(value)
+    if CORE.is_esp32:
+        if value.total_microseconds > 13:
+            raise cv.Invalid("Maximum internal filter value for ESP32 is 13us")
+        return value
+
+    return value
+
+
+def validate_pulse_counter_pin(value):
+    value = pins.internal_gpio_input_pin_schema(value)
+    if CORE.is_esp8266 and value[CONF_NUMBER] >= 16:
+        raise cv.Invalid("Pins GPIO16 and GPIO17 cannot be used as pulse counters on ESP8266.")
+    return value
+
+
+CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PulseCounterSensor),
+    cv.Required(CONF_PIN): validate_pulse_counter_pin,
+    cv.Optional(CONF_COUNT_MODE, default={
+        CONF_RISING_EDGE: 'INCREMENT',
+        CONF_FALLING_EDGE: 'DISABLE',
+    }): cv.Schema({
+        cv.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
+        cv.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
+    }),
+    cv.Optional(CONF_INTERNAL_FILTER, default='13us'): validate_internal_filter,
+    cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
+
+    cv.Optional(CONF_ACCURACY_DECIMALS, default=2): sensor.accuracy_decimals,
+    cv.Optional(CONF_ICON, default=ICON_PULSE): sensor.icon,
+    cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_PULSES_PER_MINUTE):
+        sensor.unit_of_measurement,
+}).extend(cv.COMPONENT_SCHEMA))
+
+
+def to_code(config):
+    pin = yield cg.gpio_pin_expression(config[CONF_PIN])
+    count = config[CONF_COUNT_MODE]
+    var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], pin, config[CONF_UPDATE_INTERVAL],
+                           COUNT_MODES[count[CONF_RISING_EDGE]],
+                           COUNT_MODES[count[CONF_FALLING_EDGE]],
+                           config[CONF_INTERNAL_FILTER])
+    yield cg.register_component(var, config)
+    yield sensor.register_sensor(var, config)