🏗 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/servo/__init__.py

@@ -0,0 +1,54 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components.output import FloatOutput
+from esphome.const import CONF_ID, CONF_IDLE_LEVEL, CONF_MAX_LEVEL, CONF_MIN_LEVEL, CONF_OUTPUT, \
+    CONF_LEVEL
+
+servo_ns = cg.esphome_ns.namespace('servo')
+Servo = servo_ns.class_('Servo', cg.Component)
+ServoWriteAction = servo_ns.class_('ServoWriteAction', cg.Action)
+ServoDetachAction = servo_ns.class_('ServoDetachAction', cg.Action)
+
+MULTI_CONF = True
+CONFIG_SCHEMA = cv.Schema({
+    cv.Required(CONF_ID): cv.declare_variable_id(Servo),
+    cv.Required(CONF_OUTPUT): cv.use_variable_id(FloatOutput),
+    cv.Optional(CONF_MIN_LEVEL, default='3%'): cv.percentage,
+    cv.Optional(CONF_IDLE_LEVEL, default='7.5%'): cv.percentage,
+    cv.Optional(CONF_MAX_LEVEL, default='12%'): cv.percentage,
+}).extend(cv.COMPONENT_SCHEMA)
+
+
+def to_code(config):
+    out = yield cg.get_variable(config[CONF_OUTPUT])
+    var = cg.new_Pvariable(config[CONF_ID], out)
+    cg.register_component(var, config)
+
+    cg.add(var.set_min_level(config[CONF_MIN_LEVEL]))
+    cg.add(var.set_idle_level(config[CONF_IDLE_LEVEL]))
+    cg.add(var.set_max_level(config[CONF_MAX_LEVEL]))
+
+
+@ACTION_REGISTRY.register('servo.write', cv.Schema({
+    cv.Required(CONF_ID): cv.use_variable_id(Servo),
+    cv.Required(CONF_LEVEL): cv.templatable(cv.possibly_negative_percentage),
+}))
+def servo_write_to_code(config, action_id, template_arg, args):
+    var = yield cg.get_variable(config[CONF_ID])
+    type = ServoWriteAction.template(template_arg)
+    rhs = type.new(var)
+    action = cg.Pvariable(action_id, rhs, type=type)
+    template_ = yield cg.templatable(config[CONF_LEVEL], args, float)
+    cg.add(action.set_value(template_))
+    yield action
+
+
+@ACTION_REGISTRY.register('servo.detach', maybe_simple_id({
+    cv.Required(CONF_ID): cv.use_variable_id(Servo),
+}))
+def servo_detach_to_code(config, action_id, template_arg, args):
+    var = yield cg.get_variable(config[CONF_ID])
+    type = ServoDetachAction.template(template_arg)
+    rhs = type.new(var)
+    yield cg.Pvariable(action_id, rhs, type=type)

esphome/components/servo/servo.cpp

@@ -0,0 +1,19 @@
+#include "servo.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace servo {
+
+static const char *TAG = "servo";
+
+uint32_t global_servo_id = 1911044085ULL;
+
+void Servo::dump_config() {
+  ESP_LOGCONFIG(TAG, "Servo:");
+  ESP_LOGCONFIG(TAG, "  Idle Level: %.1f%%", this->idle_level_ * 100.0f);
+  ESP_LOGCONFIG(TAG, "  Min Level: %.1f%%", this->min_level_ * 100.0f);
+  ESP_LOGCONFIG(TAG, "  Max Level: %.1f%%", this->max_level_ * 100.0f);
+}
+
+}  // namespace servo
+}  // namespace esphome

esphome/components/servo/servo.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/preferences.h"
+#include "esphome/components/output/float_output.h"
+
+namespace esphome {
+namespace servo {
+
+extern uint32_t global_servo_id;
+
+class Servo : public Component {
+ public:
+  Servo(output::FloatOutput *output) : output_(output) {}
+  void write(float value) {
+    value = clamp(value, -1.0f, 1.0f);
+
+    float level;
+    if (value < 0.0)
+      level = lerp(this->idle_level_, this->min_level_, -value);
+    else
+      level = lerp(this->idle_level_, this->max_level_, value);
+
+    this->output_->set_level(level);
+    this->save_level_(level);
+  }
+  void detach() {
+    this->output_->set_level(0.0f);
+    this->save_level_(0.0f);
+  }
+  void setup() override {
+    float v;
+    if (this->restore_) {
+      this->rtc_ = global_preferences.make_preference<float>(global_servo_id);
+      global_servo_id++;
+      if (this->rtc_.load(&v)) {
+        this->write(v);
+        return;
+      }
+    }
+    this->write(0.0f);
+  }
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_min_level(float min_level) { min_level_ = min_level; }
+  void set_idle_level(float idle_level) { idle_level_ = idle_level; }
+  void set_max_level(float max_level) { max_level_ = max_level; }
+
+ protected:
+  void save_level_(float v) { this->rtc_.save(&v); }
+
+  output::FloatOutput *output_;
+  float min_level_ = 0.0300f;
+  float idle_level_ = 0.0750f;
+  float max_level_ = 0.1200f;
+  bool restore_{false};
+  ESPPreferenceObject rtc_;
+};
+
+template<typename... Ts> class ServoWriteAction : public Action<Ts...> {
+ public:
+  ServoWriteAction(Servo *servo) : servo_(servo) {}
+  TEMPLATABLE_VALUE(float, value)
+  void play(Ts... x) override {
+    this->servo_->write(this->value_.value(x...));
+    this->play_next(x...);
+  }
+
+ protected:
+  Servo *servo_;
+};
+
+template<typename... Ts> class ServoDetachAction : public Action<Ts...> {
+ public:
+  ServoDetachAction(Servo *servo) : servo_(servo) {}
+  void play(Ts... x) override {
+    this->servo_->detach();
+    this->play_next(x...);
+  }
+
+ protected:
+  Servo *servo_;
+};
+
+}  // namespace servo
+}  // namespace esphome