Moar Custom platforms

esphome/components/custom/climate/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import climate
+from esphome.const import CONF_ID, CONF_LAMBDA
+from .. import custom_ns
+
+CustomClimateConstructor = custom_ns.class_('CustomClimateConstructor')
+CONF_CLIMATES = 'climates'
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_id(CustomClimateConstructor),
+    cv.Required(CONF_LAMBDA): cv.returning_lambda,
+    cv.Required(CONF_CLIMATES): cv.ensure_list(climate.CLIMATE_SCHEMA),
+})
+
+
+def to_code(config):
+    template_ = yield cg.process_lambda(
+        config[CONF_LAMBDA], [],
+        return_type=cg.std_vector.template(climate.Climate.operator('ptr')))
+
+    rhs = CustomClimateConstructor(template_)
+    custom = cg.variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_CLIMATES]):
+        rhs = custom.Pget_climate(i)
+        yield climate.register_climate(rhs, conf)

esphome/components/custom/climate/custom_climate.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/climate/climate.h"
+
+namespace esphome {
+namespace custom {
+
+class CustomClimateConstructor {
+ public:
+  CustomClimateConstructor(const std::function<std::vector<climate::Climate *>()> &init) { this->climates_ = init(); }
+
+  climate::Climate *get_climate(int i) { return this->climates_[i]; }
+
+ protected:
+  std::vector<climate::Climate *> climates_;
+};
+
+}  // namespace custom
+}  // namespace esphome

esphome/components/custom/cover/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import cover
+from esphome.const import CONF_ID, CONF_LAMBDA
+from .. import custom_ns
+
+CustomCoverConstructor = custom_ns.class_('CustomCoverConstructor')
+CONF_COVERS = 'covers'
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_id(CustomCoverConstructor),
+    cv.Required(CONF_LAMBDA): cv.returning_lambda,
+    cv.Required(CONF_COVERS): cv.ensure_list(cover.COVER_SCHEMA),
+})
+
+
+def to_code(config):
+    template_ = yield cg.process_lambda(
+        config[CONF_LAMBDA], [],
+        return_type=cg.std_vector.template(cover.Cover.operator('ptr')))
+
+    rhs = CustomCoverConstructor(template_)
+    custom = cg.variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_COVERS]):
+        rhs = custom.Pget_cover(i)
+        yield cover.register_cover(rhs, conf)

esphome/components/custom/cover/custom_cover.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/components/cover/cover.h"
+
+namespace esphome {
+namespace custom {
+
+class CustomCoverConstructor {
+ public:
+  CustomCoverConstructor(const std::function<std::vector<cover::Cover *>()> &init) { this->covers_ = init(); }
+
+  cover::Cover *get_cover(int i) { return this->covers_[i]; }
+
+ protected:
+  std::vector<cover::Cover *> covers_;
+};
+
+}  // namespace custom
+}  // namespace esphome

esphome/components/custom/light/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import light
+from esphome.const import CONF_ID, CONF_LAMBDA
+from .. import custom_ns
+
+CustomLightOutputConstructor = custom_ns.class_('CustomLightOutputConstructor')
+CONF_LIGHTS = 'lights'
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_id(CustomLightOutputConstructor),
+    cv.Required(CONF_LAMBDA): cv.returning_lambda,
+    cv.Required(CONF_LIGHTS): cv.ensure_list(light.RGB_LIGHT_SCHEMA),
+})
+
+
+def to_code(config):
+    template_ = yield cg.process_lambda(
+        config[CONF_LAMBDA], [],
+        return_type=cg.std_vector.template(light.LightOutput.operator('ptr')))
+
+    rhs = CustomLightOutputConstructor(template_)
+    custom = cg.variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_LIGHTS]):
+        rhs = custom.Pget_light(i)
+        yield light.register_light(rhs, conf)

esphome/components/custom/light/custom_light_output.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/light/light_output.h"
+
+namespace esphome {
+namespace custom {
+
+class CustomLightOutputConstructor {
+ public:
+  CustomLightOutputConstructor(const std::function<std::vector<light::LightOutput *>()> &init) {
+    this->outputs_ = init();
+  }
+
+  light::LightOutput *get_light(int i) { return this->outputs_[i]; }
+
+ protected:
+  std::vector<light::LightOutput *> outputs_;
+};
+
+}  // namespace custom
+}  // namespace esphome

esphome/components/custom/output/__init__.py

@@ -7,42 +7,27 @@ from .. import custom_ns
 CustomBinaryOutputConstructor = custom_ns.class_('CustomBinaryOutputConstructor')
 CustomFloatOutputConstructor = custom_ns.class_('CustomFloatOutputConstructor')
 
-BINARY_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(CustomBinaryOutputConstructor),
-    cv.Required(CONF_LAMBDA): cv.returning_lambda,
-    cv.Required(CONF_TYPE): 'binary',
-    cv.Required(CONF_OUTPUTS):
-        cv.ensure_list(output.BINARY_OUTPUT_SCHEMA.extend({
-            cv.GenerateID(): cv.declare_id(output.BinaryOutput),
-        })),
-})
+CONF_BINARY = 'binary'
+CONF_FLOAT = 'float'
 
-FLOAT_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(CustomFloatOutputConstructor),
-    cv.Required(CONF_LAMBDA): cv.returning_lambda,
-    cv.Required(CONF_TYPE): 'float',
-    cv.Required(CONF_OUTPUTS):
-        cv.ensure_list(output.FLOAT_OUTPUT_SCHEMA.extend({
-            cv.GenerateID(): cv.declare_id(output.FloatOutput),
-        })),
-})
-
-
-def validate_custom_output(value):
-    if not isinstance(value, dict):
-        raise cv.Invalid("Value must be dict")
-    if CONF_TYPE not in value:
-        raise cv.Invalid("type not specified!")
-    type = cv.string_strict(value[CONF_TYPE]).lower()
-    value[CONF_TYPE] = type
-    if type == 'binary':
-        return BINARY_SCHEMA(value)
-    if type == 'float':
-        return FLOAT_SCHEMA(value)
-    raise cv.Invalid("type must either be binary or float, not {}!".format(type))
-
-
-CONFIG_SCHEMA = validate_custom_output
+CONFIG_SCHEMA = cv.typed_schema({
+    CONF_BINARY: cv.Schema({
+        cv.GenerateID(): cv.declare_id(CustomBinaryOutputConstructor),
+        cv.Required(CONF_LAMBDA): cv.returning_lambda,
+        cv.Required(CONF_OUTPUTS):
+            cv.ensure_list(output.BINARY_OUTPUT_SCHEMA.extend({
+                cv.GenerateID(): cv.declare_id(output.BinaryOutput),
+            })),
+    }),
+    CONF_FLOAT: cv.Schema({
+        cv.GenerateID(): cv.declare_id(CustomFloatOutputConstructor),
+        cv.Required(CONF_LAMBDA): cv.returning_lambda,
+        cv.Required(CONF_OUTPUTS):
+            cv.ensure_list(output.FLOAT_OUTPUT_SCHEMA.extend({
+                cv.GenerateID(): cv.declare_id(output.FloatOutput),
+            })),
+    })
+}, lower=True)
 
 
 def to_code(config):