onkelbeh/esphome_kamstrup
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup dashboard JS (#491)

Browse Source 
* Cleanup dashboard JS

* Add vscode

* Save start_mark/end_mark

* Updates

* Updates

* Remove need for cv.nameable

It's a bit hacky but removes so much bloat from integrations

* Add enum helper

* Document APIs, and Improvements

* Fixes

* Fixes

* Update PULL_REQUEST_TEMPLATE.md

* Updates

* Updates

* Updates
This commit is contained in:
Otto Winter 2019-04-22 21:56:30 +02:00 committed by GitHub
parent 6682c43dfa
commit 8e75980ebd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
359 changed files with 4395 additions and 4223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.github/PULL_REQUEST_TEMPLATE.md vendored
View File

@ -4,11 +4,10 @@
**Related issue (if applicable):** fixes <link to issue>
**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>
**Pull request in [esphome-core](https://github.com/esphome/esphome-core) with C++ framework changes (if applicable):** esphome/esphome-core#<esphome-core 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).
- [ ] Documentation added/updated in [esphome-docs](https://github.com/esphome/esphome-docs).

31
esphome/__main__.py
View File

@ -195,8 +195,13 @@ def clean_mqtt(config, args):
return mqtt.clear_topic(config, args.topic, args.username, args.password, args.client_id)
def setup_log(debug=False):
log_level = logging.DEBUG if debug else logging.INFO
def setup_log(debug=False, quiet=False):
if debug:
log_level = logging.DEBUG
elif quiet:
log_level = logging.CRITICAL
else:
log_level = logging.INFO
logging.basicConfig(level=log_level)
fmt = "%(levelname)s %(message)s"
colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
@ -236,6 +241,13 @@ def command_config(args, config):
return 0
def command_vscode(args):
from esphome import vscode
CORE.config_path = args.configuration
vscode.read_config()
def command_compile(args, config):
exit_code = write_cpp(config)
if exit_code != 0:
@ -321,7 +333,8 @@ def command_dashboard(args):
PRE_CONFIG_ACTIONS = {
'wizard': command_wizard,
'version': command_version,
'dashboard': command_dashboard
'dashboard': command_dashboard,
'vscode': command_vscode,
}
POST_CONFIG_ACTIONS = {
@ -340,8 +353,9 @@ def parse_args(argv):
parser = argparse.ArgumentParser(prog='esphome')
parser.add_argument('-v', '--verbose', help="Enable verbose esphome logs.",
action='store_true')
parser.add_argument('--dashboard', help="Internal flag to set if the command is run from the "
"dashboard.", action='store_true')
parser.add_argument('-q', '--quiet', help="Disable all esphome logs.",
action='store_true')
parser.add_argument('--dashboard', help=argparse.SUPPRESS, action='store_true')
parser.add_argument('configuration', help='Your YAML configuration file.')
subparsers = parser.add_subparsers(help='Commands', dest='command')
@ -404,12 +418,13 @@ def parse_args(argv):
dashboard.add_argument("--open-ui", help="Open the dashboard UI in a browser.",
action='store_true')
dashboard.add_argument("--hassio",
help="Internal flag used to tell esphome is started as a Hass.io "
"add-on.",
help=argparse.SUPPRESS,
action="store_true")
dashboard.add_argument("--socket",
help="Make the dashboard serve under a unix socket", type=str)
subparsers.add_parser('vscode', help=argparse.SUPPRESS)
return parser.parse_args(argv[1:])
@ -417,7 +432,7 @@ def run_esphome(argv):
args = parse_args(argv)
CORE.dashboard = args.dashboard
setup_log(args.verbose)
setup_log(args.verbose, args.quiet)
if args.command in PRE_CONFIG_ACTIONS:
try:
return PRE_CONFIG_ACTIONS[args.command](args)

349
esphome/automation.py
View File

@ -1,15 +1,9 @@
import copy
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.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, CONF_WAIT_UNTIL, CONF_WHILE
from esphome.const import CONF_AUTOMATION_ID, CONF_CONDITION, CONF_ELSE, CONF_ID, CONF_THEN, \
CONF_TRIGGER_ID, CONF_TYPE_ID
from esphome.core import coroutine
from esphome.cpp_generator import Pvariable, TemplateArguments, add, get_variable, \
process_lambda, templatable
from esphome.cpp_types import Action, App, Component, PollingComponent, Trigger, bool_, \
esphome_ns, float_, uint32, void
from esphome.util import ServiceRegistry
from esphome.util import Registry
def maybe_simple_id(*validators):
@ -18,97 +12,49 @@ def maybe_simple_id(*validators):
def validate(value):
if isinstance(value, dict):
return validator(value)
return validator({CONF_ID: value})
with cv.remove_prepend_path([CONF_ID]):
return validator({CONF_ID: value})
return validate
def validate_recursive_condition(value):
is_list = isinstance(value, list)
value = cv.ensure_list()(value)[:]
for i, item in enumerate(value):
path = [i] if is_list else []
item = copy.deepcopy(item)
if not isinstance(item, dict):
raise cv.Invalid(u"Condition must consist of key-value mapping! Got {}".format(item),
path)
key = next((x for x in item if x != CONF_CONDITION_ID), None)
if key is None:
raise cv.Invalid(u"Key missing from action! Got {}".format(item), path)
if key not in CONDITION_REGISTRY:
raise cv.Invalid(u"Unable to find condition with the name '{}', is the "
u"component loaded?".format(key), path + [key])
item.setdefault(CONF_CONDITION_ID, None)
key2 = next((x for x in item if x not in (CONF_CONDITION_ID, key)), None)
if key2 is not None:
raise cv.Invalid(u"Cannot have two conditions in one item. Key '{}' overrides '{}'! "
u"Did you forget to indent the block inside the condition?"
u"".format(key, key2), path)
validator = CONDITION_REGISTRY[key][0]
try:
condition = validator(item[key] or {})
except cv.Invalid as err:
err.prepend(path)
raise err
value[i] = {
CONF_CONDITION_ID: cv.declare_variable_id(Condition)(item[CONF_CONDITION_ID]),
key: condition,
}
return value
def register_action(name, action_type, schema):
return ACTION_REGISTRY.register(name, action_type, schema)
def validate_recursive_action(value):
is_list = isinstance(value, list)
if not is_list:
value = [value]
for i, item in enumerate(value):
path = [i] if is_list else []
item = copy.deepcopy(item)
if not isinstance(item, dict):
raise cv.Invalid(u"Action must consist of key-value mapping! Got {}".format(item),
path)
key = next((x for x in item if x != CONF_ACTION_ID), None)
if key is None:
raise cv.Invalid(u"Key missing from action! Got {}".format(item), path)
if key not in ACTION_REGISTRY:
raise cv.Invalid(u"Unable to find action with the name '{}', is the component loaded?"
u"".format(key), path + [key])
item.setdefault(CONF_ACTION_ID, None)
key2 = next((x for x in item if x not in (CONF_ACTION_ID, key)), None)
if key2 is not None:
raise cv.Invalid(u"Cannot have two actions in one item. Key '{}' overrides '{}'! "
u"Did you forget to indent the block inside the action?"
u"".format(key, key2), path)
validator = ACTION_REGISTRY[key][0]
try:
action = validator(item[key] or {})
except cv.Invalid as err:
err.prepend(path)
raise err
value[i] = {
CONF_ACTION_ID: cv.declare_variable_id(Action)(item[CONF_ACTION_ID]),
key: action,
}
return value
def register_condition(name, condition_type, schema):
return CONDITION_REGISTRY.register(name, condition_type, schema)
ACTION_REGISTRY = ServiceRegistry()
CONDITION_REGISTRY = ServiceRegistry()
Action = cg.esphome_ns.class_('Action')
Trigger = cg.esphome_ns.class_('Trigger')
ACTION_REGISTRY = Registry()
Condition = cg.esphome_ns.class_('Condition')
CONDITION_REGISTRY = Registry()
validate_action = cv.validate_registry_entry('action', ACTION_REGISTRY)
validate_action_list = cv.validate_registry('action', ACTION_REGISTRY)
validate_condition = cv.validate_registry_entry('condition', CONDITION_REGISTRY)
validate_condition_list = cv.validate_registry('condition', CONDITION_REGISTRY)
# pylint: disable=invalid-name
DelayAction = esphome_ns.class_('DelayAction', Action, Component)
LambdaAction = esphome_ns.class_('LambdaAction', Action)
IfAction = esphome_ns.class_('IfAction', Action)
WhileAction = esphome_ns.class_('WhileAction', Action)
WaitUntilAction = esphome_ns.class_('WaitUntilAction', Action, Component)
UpdateComponentAction = esphome_ns.class_('UpdateComponentAction', Action)
Automation = esphome_ns.class_('Automation')
Condition = esphome_ns.class_('Condition')
AndCondition = esphome_ns.class_('AndCondition', Condition)
OrCondition = esphome_ns.class_('OrCondition', Condition)
RangeCondition = esphome_ns.class_('RangeCondition', Condition)
LambdaCondition = esphome_ns.class_('LambdaCondition', Condition)
def validate_potentially_and_condition(value):
if isinstance(value, list):
with cv.remove_prepend_path(['and']):
return validate_condition({
'and': value
})
return validate_condition(value)
DelayAction = cg.esphome_ns.class_('DelayAction', Action, cg.Component)
LambdaAction = cg.esphome_ns.class_('LambdaAction', Action)
IfAction = cg.esphome_ns.class_('IfAction', Action)
WhileAction = cg.esphome_ns.class_('WhileAction', Action)
WaitUntilAction = cg.esphome_ns.class_('WaitUntilAction', Action, cg.Component)
UpdateComponentAction = cg.esphome_ns.class_('UpdateComponentAction', Action)
Automation = cg.esphome_ns.class_('Automation')
LambdaCondition = cg.esphome_ns.class_('LambdaCondition', Condition)
def validate_automation(extra_schema=None, extra_validators=None, single=False):
@ -120,24 +66,26 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
def validator_(value):
if isinstance(value, list):
# List of items, there are two possible options here, either a sequence of
# actions (no then:) or a list of automations.
try:
# First try as a sequence of actions
return [schema({CONF_THEN: value})]
# If that succeeds, return immediately
with cv.remove_prepend_path([CONF_THEN]):
return [schema({CONF_THEN: value})]
except cv.Invalid as err:
if err.path and err.path[0] == CONF_THEN:
err.path.pop(0)
# Next try as a sequence of automations
try:
return cv.Schema([schema])(value)
except cv.Invalid as err2:
if 'Unable to find action' in str(err):
if u'Unable to find action' in str(err):
raise err2
raise cv.MultipleInvalid([err, err2])
raise cv.MultipleInvalid([err, err2])
elif isinstance(value, dict):
if CONF_THEN in value:
return [schema(value)]
return [schema({CONF_THEN: value})]
with cv.remove_prepend_path([CONF_THEN]):
return [schema({CONF_THEN: value})]
# This should only happen with invalid configs, but let's have a nice error message.
return [schema(value)]
@ -155,175 +103,119 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
AUTOMATION_SCHEMA = cv.Schema({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(Trigger),
cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(Automation),
cv.Required(CONF_THEN): validate_recursive_action,
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(Trigger),
cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_id(Automation),
cv.Required(CONF_THEN): validate_action_list,
})
AND_CONDITION_SCHEMA = validate_recursive_condition
AndCondition = cg.esphome_ns.class_('AndCondition', Condition)
OrCondition = cg.esphome_ns.class_('OrCondition', Condition)
NotCondition = cg.esphome_ns.class_('NotCondition', Condition)
@CONDITION_REGISTRY.register(CONF_AND, AND_CONDITION_SCHEMA)
@register_condition('and', AndCondition, validate_condition_list)
def and_condition_to_code(config, condition_id, template_arg, args):
conditions = yield build_conditions(config, template_arg, args)
rhs = AndCondition.new(template_arg, conditions)
type = AndCondition.template(template_arg)
yield Pvariable(condition_id, rhs, type=type)
conditions = yield build_condition_list(config, template_arg, args)
yield cg.new_Pvariable(condition_id, template_arg, conditions)
OR_CONDITION_SCHEMA = validate_recursive_condition
@CONDITION_REGISTRY.register(CONF_OR, OR_CONDITION_SCHEMA)
@register_condition('or', OrCondition, validate_condition_list)
def or_condition_to_code(config, condition_id, template_arg, args):
conditions = yield build_conditions(config, template_arg, args)
rhs = OrCondition.new(template_arg, conditions)
type = OrCondition.template(template_arg)
yield Pvariable(condition_id, rhs, type=type)
conditions = yield build_condition_list(config, template_arg, args)
yield cg.new_Pvariable(condition_id, template_arg, conditions)
RANGE_CONDITION_SCHEMA = cv.All(cv.Schema({
cv.Optional(CONF_ABOVE): cv.templatable(cv.float_),
cv.Optional(CONF_BELOW): cv.templatable(cv.float_),
}), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
@register_condition('not', NotCondition, validate_condition)
def not_condition_to_code(config, condition_id, template_arg, args):
condition = yield build_condition(config, template_arg, args)
yield cg.new_Pvariable(condition_id, template_arg, condition)
@CONDITION_REGISTRY.register(CONF_RANGE, RANGE_CONDITION_SCHEMA)
def range_condition_to_code(config, condition_id, template_arg, args):
conditions = yield build_conditions(config, template_arg, args)
rhs = RangeCondition.new(template_arg, conditions)
type = RangeCondition.template(template_arg)
condition = Pvariable(condition_id, rhs, type=type)
if CONF_ABOVE in config:
template_ = yield templatable(config[CONF_ABOVE], args, float_)
condition.set_min(template_)
if CONF_BELOW in config:
template_ = yield templatable(config[CONF_BELOW], args, float_)
condition.set_max(template_)
yield condition
@register_condition('lambda', LambdaCondition, cv.lambda_)
def lambda_condition_to_code(config, condition_id, template_arg, args):
lambda_ = yield cg.process_lambda(config, args, return_type=bool)
yield cg.new_Pvariable(condition_id, template_arg, lambda_)
DELAY_ACTION_SCHEMA = cv.templatable(cv.positive_time_period_milliseconds)
@ACTION_REGISTRY.register(CONF_DELAY, DELAY_ACTION_SCHEMA)
@register_action('delay', DelayAction, cv.templatable(cv.positive_time_period_milliseconds))
def delay_action_to_code(config, action_id, template_arg, args):
rhs = App.register_component(DelayAction.new(template_arg))
type = DelayAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
template_ = yield templatable(config, args, uint32)
add(action.set_delay(template_))
yield action
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_component(var, {})
template_ = yield cg.templatable(config, args, cg.uint32)
cg.add(var.set_delay(template_))
yield var
IF_ACTION_SCHEMA = cv.All({
cv.Required(CONF_CONDITION): validate_recursive_condition,
cv.Optional(CONF_THEN): validate_recursive_action,
cv.Optional(CONF_ELSE): validate_recursive_action,
}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE))
@ACTION_REGISTRY.register(CONF_IF, IF_ACTION_SCHEMA)
@register_action('if', IfAction, cv.All({
cv.Required(CONF_CONDITION): validate_potentially_and_condition,
cv.Optional(CONF_THEN): validate_action_list,
cv.Optional(CONF_ELSE): validate_action_list,
}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE)))
def if_action_to_code(config, action_id, template_arg, args):
conditions = yield build_conditions(config[CONF_CONDITION], template_arg, args)
rhs = IfAction.new(template_arg, conditions)
type = IfAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
var = cg.new_Pvariable(action_id, template_arg, conditions)
if CONF_THEN in config:
actions = yield build_actions(config[CONF_THEN], template_arg, args)
add(action.add_then(actions))
actions = yield build_action_list(config[CONF_THEN], template_arg, args)
cg.add(var.add_then(actions))
if CONF_ELSE in config:
actions = yield build_actions(config[CONF_ELSE], template_arg, args)
add(action.add_else(actions))
yield action
actions = yield build_action_list(config[CONF_ELSE], template_arg, args)
cg.add(var.add_else(actions))
yield var
WHILE_ACTION_SCHEMA = cv.Schema({
cv.Required(CONF_CONDITION): validate_recursive_condition,
cv.Required(CONF_THEN): validate_recursive_action,
})
@ACTION_REGISTRY.register(CONF_WHILE, WHILE_ACTION_SCHEMA)
@register_action('while', WhileAction, cv.Schema({
cv.Required(CONF_CONDITION): validate_potentially_and_condition,
cv.Required(CONF_THEN): validate_action_list,
}))
def while_action_to_code(config, action_id, template_arg, args):
conditions = yield build_conditions(config[CONF_CONDITION], template_arg, args)
rhs = WhileAction.new(template_arg, conditions)
type = WhileAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
actions = yield build_actions(config[CONF_THEN], template_arg, args)
add(action.add_then(actions))
yield action
conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
var = cg.new_Pvariable(action_id, template_arg, conditions)
actions = yield build_action_list(config[CONF_THEN], template_arg, args)
cg.add(var.add_then(actions))
yield var
def validate_wait_until(value):
schema = cv.Schema({
cv.Required(CONF_CONDITION): validate_recursive_condition
cv.Required(CONF_CONDITION): validate_potentially_and_condition,
})
if isinstance(value, dict) and CONF_CONDITION in value:
return schema(value)
return validate_wait_until({CONF_CONDITION: value})
WAIT_UNTIL_ACTION_SCHEMA = validate_wait_until
@ACTION_REGISTRY.register(CONF_WAIT_UNTIL, WAIT_UNTIL_ACTION_SCHEMA)
@register_action('wait_until', WaitUntilAction, validate_wait_until)
def wait_until_action_to_code(config, action_id, template_arg, args):
conditions = yield build_conditions(config[CONF_CONDITION], template_arg, args)
rhs = WaitUntilAction.new(template_arg, conditions)
type = WaitUntilAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
add(App.register_component(action))
yield action
conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
var = cg.new_Pvariable(action_id, template_arg, conditions)
yield cg.register_component(var, {})
yield var
LAMBDA_ACTION_SCHEMA = cv.lambda_
@ACTION_REGISTRY.register(CONF_LAMBDA, LAMBDA_ACTION_SCHEMA)
@register_action('lambda', LambdaAction, cv.lambda_)
def lambda_action_to_code(config, action_id, template_arg, args):
lambda_ = yield process_lambda(config, args, return_type=void)
rhs = LambdaAction.new(template_arg, lambda_)
type = LambdaAction.template(template_arg)
yield Pvariable(action_id, rhs, type=type)
lambda_ = yield cg.process_lambda(config, args, return_type=cg.void)
yield cg.new_Pvariable(action_id, template_arg, lambda_)
LAMBDA_CONDITION_SCHEMA = cv.lambda_
@CONDITION_REGISTRY.register(CONF_LAMBDA, LAMBDA_CONDITION_SCHEMA)
def lambda_condition_to_code(config, condition_id, template_arg, args):
lambda_ = yield process_lambda(config, args, return_type=bool_)
rhs = LambdaCondition.new(template_arg, lambda_)
type = LambdaCondition.template(template_arg)
yield Pvariable(condition_id, rhs, type=type)
CONF_COMPONENT_UPDATE = 'component.update'
COMPONENT_UPDATE_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(PollingComponent),
})
@ACTION_REGISTRY.register(CONF_COMPONENT_UPDATE, COMPONENT_UPDATE_ACTION_SCHEMA)
@register_action('component.update', UpdateComponentAction, maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
}))
def component_update_action_to_code(config, action_id, template_arg, args):
var = yield get_variable(config[CONF_ID])
rhs = UpdateComponentAction.new(template_arg, var)
type = UpdateComponentAction.template(template_arg)
yield Pvariable(action_id, rhs, type=type)
comp = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, comp)
@coroutine
def build_action(full_config, template_arg, args):
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 = coroutine(ACTION_REGISTRY[key][1])
registry_entry, config = cg.extract_registry_entry_config(ACTION_REGISTRY, full_config)
action_id = full_config[CONF_TYPE_ID]
builder = registry_entry.coroutine_fun
yield builder(config, action_id, template_arg, args)
@coroutine
def build_actions(config, templ, arg_type):
def build_action_list(config, templ, arg_type):
actions = []
for conf in config:
action = yield build_action(conf, templ, arg_type)
@ -333,15 +225,14 @@ def build_actions(config, templ, arg_type):
@coroutine
def build_condition(full_config, template_arg, args):
action_id = full_config[CONF_CONDITION_ID]
key, config = next((k, v) for k, v in full_config.items() if k in CONDITION_REGISTRY)
builder = coroutine(CONDITION_REGISTRY[key][1])
registry_entry, config = cg.extract_registry_entry_config(CONDITION_REGISTRY, full_config)
action_id = full_config[CONF_TYPE_ID]
builder = registry_entry.coroutine_fun
yield builder(config, action_id, template_arg, args)
@coroutine
def build_conditions(config, templ, args):
def build_condition_list(config, templ, args):
conditions = []
for conf in config:
condition = yield build_condition(conf, templ, args)
@ -352,10 +243,8 @@ def build_conditions(config, templ, args):
@coroutine
def build_automation(trigger, args, config):
arg_types = [arg[0] for arg in args]
templ = TemplateArguments(*arg_types)
type = Automation.template(templ)
rhs = type.new(trigger)
obj = Pvariable(config[CONF_AUTOMATION_ID], rhs, type=type)
actions = yield build_actions(config[CONF_THEN], templ, args)
add(obj.add_actions(actions))
templ = cg.TemplateArguments(*arg_types)
obj = cg.new_Pvariable(config[CONF_AUTOMATION_ID], templ, trigger)
actions = yield build_action_list(config[CONF_THEN], templ, args)
cg.add(obj.add_actions(actions))
yield obj

4
esphome/codegen.py
View File

@ -17,10 +17,10 @@ from esphome.cpp_generator import ( # noqa
MockObjClass)
from esphome.cpp_helpers import ( # noqa
gpio_pin_expression, register_component, build_registry_entry,
build_registry_list)
build_registry_list, extract_registry_entry_config)
from esphome.cpp_types import ( # noqa
global_ns, void, nullptr, float_, bool_, std_ns, std_string,
std_vector, uint8, uint16, uint32, int32, const_char_ptr, NAN,
esphome_ns, App, Nameable, Trigger, Action, Component, ComponentPtr,
esphome_ns, App, Nameable, Component, ComponentPtr,
PollingComponent, Application, optional, arduino_json_ns, JsonObject,
JsonObjectRef, JsonObjectConstRef, Controller, GPIOPin)

3
esphome/components/a4988/a4988.h
View File

@ -9,7 +9,8 @@ namespace a4988 {
class A4988 : public stepper::Stepper, public Component {
public:
A4988(GPIOPin *step_pin, GPIOPin *dir_pin) : step_pin_(step_pin), dir_pin_(dir_pin) {}
void set_step_pin(GPIOPin *step_pin) { step_pin_ = step_pin; }
void set_dir_pin(GPIOPin *dir_pin) { dir_pin_ = dir_pin; }
void set_sleep_pin(GPIOPin *sleep_pin) { this->sleep_pin_ = sleep_pin; }
void setup() override;
void dump_config() override;

11
esphome/components/a4988/stepper.py
View File

@ -9,7 +9,7 @@ a4988_ns = cg.esphome_ns.namespace('a4988')
A4988 = a4988_ns.class_('A4988', stepper.Stepper, cg.Component)
CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend({
cv.Required(CONF_ID): cv.declare_variable_id(A4988),
cv.Required(CONF_ID): cv.declare_id(A4988),
cv.Required(CONF_STEP_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_DIR_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_SLEEP_PIN): pins.gpio_output_pin_schema,
@ -17,12 +17,15 @@ CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend({
def to_code(config):
step_pin = yield cg.gpio_pin_expression(config[CONF_STEP_PIN])
dir_pin = yield cg.gpio_pin_expression(config[CONF_DIR_PIN])
var = cg.new_Pvariable(config[CONF_ID], step_pin, dir_pin)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield stepper.register_stepper(var, config)
step_pin = yield cg.gpio_pin_expression(config[CONF_STEP_PIN])
cg.add(var.set_step_pin(step_pin))
dir_pin = yield cg.gpio_pin_expression(config[CONF_DIR_PIN])
cg.add(var.set_dir_pin(dir_pin))
if CONF_SLEEP_PIN in config:
sleep_pin = yield cg.gpio_pin_expression(config[CONF_SLEEP_PIN])
cg.add(var.set_sleep_pin(sleep_pin))

3
esphome/components/adc/adc_sensor.cpp
View File

@ -6,9 +6,6 @@ namespace adc {
static const char *TAG = "adc";
ADCSensor::ADCSensor(const std::string &name, uint8_t pin, uint32_t update_interval)
: PollingSensorComponent(name, update_interval), pin_(pin) {}
#ifdef ARDUINO_ARCH_ESP32
void ADCSensor::set_attenuation(adc_attenuation_t attenuation) { this->attenuation_ = attenuation; }
#endif

6
esphome/components/adc/adc_sensor.h
View File

@ -7,11 +7,8 @@
namespace esphome {
namespace adc {
class ADCSensor : public sensor::PollingSensorComponent {
class ADCSensor : public sensor::Sensor, public PollingComponent {
public:
/// Construct the ADCSensor with the provided pin and update interval in ms.
explicit ADCSensor(const std::string &name, uint8_t pin, uint32_t update_interval);
#ifdef ARDUINO_ARCH_ESP32
/// Set the attenuation for this pin. Only available on the ESP32.
void set_attenuation(adc_attenuation_t attenuation);
@ -26,6 +23,7 @@ class ADCSensor : public sensor::PollingSensorComponent {
void dump_config() override;
/// `HARDWARE_LATE` setup priority.
float get_setup_priority() const override;
void set_pin(uint8_t pin) { this->pin_ = pin; }
#ifdef ARDUINO_ARCH_ESP8266
std::string unique_id() override;

33
esphome/components/adc/sensor.py
View File

@ -2,8 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import sensor
from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL, \
CONF_ICON, ICON_FLASH, CONF_UNIT_OF_MEASUREMENT, UNIT_VOLT, CONF_ACCURACY_DECIMALS
from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_PIN, ICON_FLASH, UNIT_VOLT
ATTENUATION_MODES = {
'0db': cg.global_ns.ADC_0db,
@ -23,30 +22,24 @@ def validate_adc_pin(value):
adc_ns = cg.esphome_ns.namespace('adc')
ADCSensor = adc_ns.class_('ADCSensor', sensor.PollingSensorComponent)
CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(ADCSensor),
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2).extend({
cv.GenerateID(): cv.declare_id(ADCSensor),
cv.Required(CONF_PIN): validate_adc_pin,
cv.Optional(CONF_ATTENUATION): cv.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES,
lower=True)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
cv.Optional(CONF_ICON, default=ICON_FLASH): sensor.icon,
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_VOLT): sensor.unit_of_measurement,
cv.Optional(CONF_ACCURACY_DECIMALS, default=2): sensor.accuracy_decimals,
}).extend(cv.COMPONENT_SCHEMA))
cv.SplitDefault(CONF_ATTENUATION, esp32='0db'):
cv.All(cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=True)),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
pin = config[CONF_PIN]
if pin == 'VCC':
pin = 0
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
if config[CONF_PIN] == 'VCC':
cg.add_define('USE_ADC_SENSOR_VCC')
cg.add_global(cg.global_ns.ADC_MODE(cg.global_ns.ADC_VCC))
rhs = ADCSensor.new(config[CONF_NAME], pin, config[CONF_UPDATE_INTERVAL])
adc = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(adc, config)
yield sensor.register_sensor(adc, config)
else:
cg.add(var.set_pin(config[CONF_PIN]))
if CONF_ATTENUATION in config:
cg.add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
cg.add(var.set_attenuation(config[CONF_ATTENUATION]))

2
esphome/components/ads1115/__init__.py
View File

@ -11,7 +11,7 @@ ads1115_ns = cg.esphome_ns.namespace('ads1115')
ADS1115Component = ads1115_ns.class_('ADS1115Component', cg.Component, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(ADS1115Component),
cv.GenerateID(): cv.declare_id(ADS1115Component),
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(None))

3
esphome/components/ads1115/ads1115.h
View File

@ -48,9 +48,6 @@ class ADS1115Component : public Component, public i2c::I2CDevice {
/// Internal holder class that is in instance of Sensor so that the hub can create individual sensors.
class ADS1115Sensor : public sensor::Sensor {
public:
ADS1115Sensor(const std::string &name, uint32_t update_interval)
: sensor::Sensor(name), update_interval_(update_interval) {}
void set_multiplexer(ADS1115Multiplexer multiplexer);
void set_gain(ADS1115Gain gain);

26
esphome/components/ads1115/sensor.py
View File

@ -2,8 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.components.ads1115 import ADS1115Component
from esphome.const import CONF_GAIN, CONF_MULTIPLEXER, CONF_UPDATE_INTERVAL, \
ICON_FLASH, UNIT_VOLT, CONF_ID, CONF_NAME
from esphome.const import CONF_GAIN, CONF_MULTIPLEXER, ICON_FLASH, UNIT_VOLT, CONF_ID
from esphome.py_compat import string_types
from . import ads1115_ns
@ -38,27 +37,26 @@ def validate_gain(value):
elif not isinstance(value, string_types):
raise cv.Invalid('invalid gain "{}"'.format(value))
return cv.one_of(*GAIN)(value)
return cv.enum(GAIN)(value)
ADS1115Sensor = ads1115_ns.class_('ADS1115Sensor', sensor.Sensor)
CONF_ADS1115_ID = 'ads1115_id'
CONFIG_SCHEMA = cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 3).extend({
cv.GenerateID(): cv.declare_variable_id(ADS1115Sensor),
cv.GenerateID(CONF_ADS1115_ID): cv.use_variable_id(ADS1115Component),
cv.Required(CONF_MULTIPLEXER): cv.one_of(*MUX, upper=True, space='_'),
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 3).extend({
cv.GenerateID(): cv.declare_id(ADS1115Sensor),
cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space='_'),
cv.Required(CONF_GAIN): validate_gain,
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}))
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
hub = yield cg.get_variable(config[CONF_ADS1115_ID])
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_UPDATE_INTERVAL])
cg.add(var.set_multiplexer(MUX[config[CONF_MULTIPLEXER]]))
cg.add(var.set_gain(GAIN[config[CONF_GAIN]]))
var = cg.new_Pvariable(config[CONF_ID])
yield sensor.register_sensor(var, config)
cg.add(var.set_multiplexer(config[CONF_MULTIPLEXER]))
cg.add(var.set_gain(config[CONF_GAIN]))
hub = yield cg.get_variable(config[CONF_ADS1115_ID])
cg.add(hub.register_sensor(var))

9
esphome/components/apds9960/__init__.py
View File

@ -1,7 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c
from esphome.const import CONF_ID, CONF_UPDATE_INTERVAL
from esphome.const import CONF_ID
DEPENDENCIES = ['i2c']
AUTO_LOAD = ['sensor', 'binary_sensor']
@ -13,12 +13,11 @@ apds9960_nds = cg.esphome_ns.namespace('apds9960')
APDS9960 = apds9960_nds.class_('APDS9960', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(APDS9960),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x39))
cv.GenerateID(): cv.declare_id(APDS9960),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x39))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

1
esphome/components/apds9960/apds9960.h
View File

@ -10,7 +10,6 @@ namespace apds9960 {
class APDS9960 : public PollingComponent, public i2c::I2CDevice {
public:
APDS9960(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

6
esphome/components/apds9960/binary_sensor.py
View File

@ -13,11 +13,11 @@ DIRECTIONS = {
'RIGHT': 'set_right_direction',
}
CONFIG_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960),
cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
cv.Optional(CONF_DEVICE_CLASS, default=DEVICE_CLASS_MOVING): binary_sensor.device_class,
}))
})
def to_code(config):

13
esphome/components/apds9960/sensor.py
View File

@ -1,8 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import CONF_TYPE, CONF_UNIT_OF_MEASUREMENT, CONF_ACCURACY_DECIMALS, CONF_ICON, \
UNIT_PERCENT, ICON_LIGHTBULB
from esphome.const import CONF_TYPE, UNIT_PERCENT, ICON_LIGHTBULB
from . import APDS9960, CONF_APDS9960_ID
DEPENDENCIES = ['apds9960']
@ -15,14 +14,10 @@ TYPES = {
'PROXIMITY': 'set_proximity',
}
CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_PERCENT, ICON_LIGHTBULB, 1).extend({
cv.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960),
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_PERCENT): sensor.unit_of_measurement,
cv.Optional(CONF_ACCURACY_DECIMALS, default=1): sensor.accuracy_decimals,
cv.Optional(CONF_ICON, default=ICON_LIGHTBULB): sensor.icon,
}))
cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
})
def to_code(config):

68
esphome/components/api/__init__.py
View File

@ -1,20 +1,21 @@
from esphome import automation
from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.automation import Condition
from esphome.const import CONF_DATA, CONF_DATA_TEMPLATE, CONF_ID, CONF_PASSWORD, CONF_PORT, \
CONF_REBOOT_TIMEOUT, CONF_SERVICE, CONF_VARIABLES, CONF_SERVICES, CONF_TRIGGER_ID
from esphome.core import CORE, coroutine_with_priority
DEPENDENCIES = ['network']
api_ns = cg.esphome_ns.namespace('api')
APIServer = api_ns.class_('APIServer', cg.Component, cg.Controller)
HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', cg.Action)
HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', automation.Action)
KeyValuePair = api_ns.class_('KeyValuePair')
TemplatableKeyValuePair = api_ns.class_('TemplatableKeyValuePair')
APIConnectedCondition = api_ns.class_('APIConnectedCondition', Condition)
UserService = api_ns.class_('UserService', cg.Trigger)
UserService = api_ns.class_('UserService', automation.Trigger)
ServiceTypeArgument = api_ns.class_('ServiceTypeArgument')
ServiceArgType = api_ns.enum('ServiceArgType')
SERVICE_ARG_TYPES = {
@ -30,14 +31,13 @@ SERVICE_ARG_NATIVE_TYPES = {
'string': cg.std_string,
}
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(APIServer),
cv.GenerateID(): cv.declare_id(APIServer),
cv.Optional(CONF_PORT, default=6053): cv.port,
cv.Optional(CONF_PASSWORD, default=''): cv.string_strict,
cv.Optional(CONF_REBOOT_TIMEOUT, default='5min'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_SERVICES): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(UserService),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserService),
cv.Required(CONF_SERVICE): cv.valid_name,
cv.Optional(CONF_VARIABLES, default={}): cv.Schema({
cv.validate_id_name: cv.one_of(*SERVICE_ARG_TYPES, lower=True),
@ -48,13 +48,12 @@ CONFIG_SCHEMA = cv.Schema({
@coroutine_with_priority(40.0)
def to_code(config):
rhs = APIServer.new()
api = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(api, config)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(api.set_port(config[CONF_PORT]))
cg.add(api.set_password(config[CONF_PASSWORD]))
cg.add(api.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
cg.add(var.set_port(config[CONF_PORT]))
cg.add(var.set_password(config[CONF_PASSWORD]))
cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
for conf in config.get(CONF_SERVICES, []):
template_args = []
@ -65,10 +64,9 @@ def to_code(config):
template_args.append(native)
func_args.append((native, name))
service_type_args.append(ServiceTypeArgument(name, SERVICE_ARG_TYPES[var_]))
func = api.make_user_service_trigger.template(*template_args)
rhs = func(conf[CONF_SERVICE], service_type_args)
type_ = UserService.template(*template_args)
trigger = cg.Pvariable(conf[CONF_TRIGGER_ID], rhs, type=type_)
templ = cg.TemplateArguments(*template_args)
trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], templ,
conf[CONF_SERVICE], service_type_args)
yield automation.build_automation(trigger, func_args, conf)
cg.add_define('USE_API')
@ -78,9 +76,8 @@ def to_code(config):
cg.add_library('ESPAsyncTCP', '1.2.0')
CONF_HOMEASSISTANT_SERVICE = 'homeassistant.service'
HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema({
cv.GenerateID(): cv.use_variable_id(APIServer),
cv.GenerateID(): cv.use_id(APIServer),
cv.Required(CONF_SERVICE): cv.string,
cv.Optional(CONF_DATA): cv.Schema({
cv.string: cv.string,
@ -94,34 +91,27 @@ HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema({
})
@ACTION_REGISTRY.register(CONF_HOMEASSISTANT_SERVICE, HOMEASSISTANT_SERVICE_ACTION_SCHEMA)
@automation.register_action('homeassistant.service', HomeAssistantServiceCallAction,
HOMEASSISTANT_SERVICE_ACTION_SCHEMA)
def homeassistant_service_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = HomeAssistantServiceCallAction.template(template_arg)
rhs = type.new(var)
act = cg.Pvariable(action_id, rhs, type=type)
cg.add(act.set_service(config[CONF_SERVICE]))
serv = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, serv)
cg.add(var.set_service(config[CONF_SERVICE]))
if CONF_DATA in config:
datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA].items()]
cg.add(act.set_data(datas))
cg.add(var.set_data(datas))
if CONF_DATA_TEMPLATE in config:
datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA_TEMPLATE].items()]
cg.add(act.set_data_template(datas))
cg.add(var.set_data_template(datas))
if CONF_VARIABLES in config:
datas = []
for key, value in config[CONF_VARIABLES].items():
value_ = yield cg.process_lambda(value, [])
datas.append(TemplatableKeyValuePair(key, value_))
cg.add(act.set_variables(datas))
yield act
cg.add(var.set_variables(datas))
yield var
CONF_API_CONNECTED = 'api.connected'
API_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
@CONDITION_REGISTRY.register(CONF_API_CONNECTED, API_CONNECTED_CONDITION_SCHEMA)
@automation.register_condition('api.connected', APIConnectedCondition, {})
def api_connected_to_code(config, condition_id, template_arg, args):
rhs = APIConnectedCondition.new(template_arg)
type = APIConnectedCondition.template(template_arg)
yield cg.Pvariable(condition_id, rhs, type=type)
yield cg.new_Pvariable(condition_id, template_arg)

2
esphome/components/api/api_server.cpp
View File

@ -999,7 +999,7 @@ bool APIConnection::send_log_message(int level, const char *tag, const char *lin
bool success = this->send_buffer(APIMessageType::SUBSCRIBE_LOGS_RESPONSE);
if (!success) {
auto buffer = this->get_buffer();
buffer = this->get_buffer();
// bool send_failed = 4;
buffer.encode_bool(4, true);
return this->send_buffer(APIMessageType::SUBSCRIBE_LOGS_RESPONSE);

5
esphome/components/api/api_server.h
View File

@ -226,10 +226,7 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
this->resp_.set_data_template(data_template);
}
void set_variables(const std::vector<TemplatableKeyValuePair> &variables) { this->resp_.set_variables(variables); }
void play(Ts... x) override {
this->parent_->send_service_call(this->resp_);
this->play_next(x...);
}
void play(Ts... x) override { this->parent_->send_service_call(this->resp_); }
protected:
APIServer *parent_;

7
esphome/components/bang_bang/bang_bang_climate.cpp
View File

@ -138,11 +138,8 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
this->supports_away_ = true;
this->away_config_ = away_config;
}
BangBangClimate::BangBangClimate(const std::string &name)
: climate::Climate(name),
idle_trigger_(new Trigger<>()),
cool_trigger_(new Trigger<>()),
heat_trigger_(new Trigger<>()) {}
BangBangClimate::BangBangClimate()
: idle_trigger_(new Trigger<>()), cool_trigger_(new Trigger<>()), heat_trigger_(new Trigger<>()) {}
void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
Trigger<> *BangBangClimate::get_idle_trigger() const { return this->idle_trigger_; }
Trigger<> *BangBangClimate::get_cool_trigger() const { return this->cool_trigger_; }

2
esphome/components/bang_bang/bang_bang_climate.h
View File

@ -19,7 +19,7 @@ struct BangBangClimateTargetTempConfig {
class BangBangClimate : public climate::Climate, public Component {
public:
BangBangClimate(const std::string &name);
BangBangClimate();
void setup() override;
void set_sensor(sensor::Sensor *sensor);

10
esphome/components/bang_bang/climate.py
View File

@ -4,15 +4,15 @@ from esphome import automation
from esphome.components import climate, sensor
from esphome.const import CONF_AWAY_CONFIG, CONF_COOL_ACTION, \
CONF_DEFAULT_TARGET_TEMPERATURE_HIGH, CONF_DEFAULT_TARGET_TEMPERATURE_LOW, CONF_HEAT_ACTION, \
CONF_ID, CONF_IDLE_ACTION, CONF_NAME, CONF_SENSOR
CONF_ID, CONF_IDLE_ACTION, CONF_SENSOR
bang_bang_ns = cg.esphome_ns.namespace('bang_bang')
BangBangClimate = bang_bang_ns.class_('BangBangClimate', climate.ClimateDevice)
BangBangClimateTargetTempConfig = bang_bang_ns.struct('BangBangClimateTargetTempConfig')
CONFIG_SCHEMA = cv.nameable(climate.CLIMATE_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(BangBangClimate),
cv.Required(CONF_SENSOR): cv.use_variable_id(sensor.Sensor),
CONFIG_SCHEMA = cv.All(climate.CLIMATE_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(BangBangClimate),
cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
@ -26,7 +26,7 @@ CONFIG_SCHEMA = cv.nameable(climate.CLIMATE_SCHEMA.extend({
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield climate.register_climate(var, config)

3
esphome/components/bh1750/bh1750.cpp
View File

@ -8,9 +8,6 @@ static const char *TAG = "bh1750.sensor";
static const uint8_t BH1750_COMMAND_POWER_ON = 0b00000001;
BH1750Sensor::BH1750Sensor(const std::string &name, uint32_t update_interval)
: PollingSensorComponent(name, update_interval) {}
void BH1750Sensor::setup() {
ESP_LOGCONFIG(TAG, "Setting up BH1750 '%s'...", this->name_.c_str());
if (!this->write_bytes(BH1750_COMMAND_POWER_ON, nullptr, 0)) {

4
esphome/components/bh1750/bh1750.h
View File

@ -15,10 +15,8 @@ enum BH1750Resolution {
};
/// This class implements support for the i2c-based BH1750 ambient light sensor.
class BH1750Sensor : public sensor::PollingSensorComponent, public i2c::I2CDevice {
class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c::I2CDevice {
public:
BH1750Sensor(const std::string &name, uint32_t update_interval);
/** Set the resolution of this sensor.
*
* Possible values are:

16
esphome/components/bh1750/sensor.py
View File

@ -1,8 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_ID, CONF_NAME, CONF_RESOLUTION, CONF_UPDATE_INTERVAL, UNIT_LUX, \
ICON_BRIGHTNESS_5
from esphome.const import CONF_ID, CONF_RESOLUTION, UNIT_LUX, ICON_BRIGHTNESS_5
DEPENDENCIES = ['i2c']
@ -16,17 +15,16 @@ BH1750_RESOLUTIONS = {
BH1750Sensor = bh1750_ns.class_('BH1750Sensor', sensor.PollingSensorComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.nameable(sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1).extend({
cv.GenerateID(): cv.declare_variable_id(BH1750Sensor),
cv.Optional(CONF_RESOLUTION, default=0.0): cv.one_of(*BH1750_RESOLUTIONS, float=True),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x23)))
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1).extend({
cv.GenerateID(): cv.declare_id(BH1750Sensor),
cv.Optional(CONF_RESOLUTION, default=0.5): cv.enum(BH1750_RESOLUTIONS, float=True),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x23))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
yield i2c.register_i2c_device(var, config)
cg.add(var.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
cg.add(var.set_resolution(config[CONF_RESOLUTION]))

22
esphome/components/binary/fan/__init__.py
View File

@ -1,25 +1,27 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import fan, output
from esphome.const import CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, \
CONF_OUTPUT_ID
from esphome.const import CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_OUTPUT_ID
from .. import binary_ns
BinaryFan = binary_ns.class_('BinaryFan', cg.Component)
CONFIG_SCHEMA = cv.nameable(fan.FAN_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_variable_id(BinaryFan),
cv.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput),
}).extend(cv.COMPONENT_SCHEMA))
CONFIG_SCHEMA = fan.FAN_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(BinaryFan),
cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_id(output.BinaryOutput),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
output_ = yield cg.get_variable(config[CONF_OUTPUT])
state = yield fan.create_fan_state(config)
var = cg.new_Pvariable(config[CONF_OUTPUT_ID], state, output_)
var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
yield cg.register_component(var, config)
fan_ = yield fan.create_fan_state(config)
cg.add(var.set_fan(fan_))
output_ = yield cg.get_variable(config[CONF_OUTPUT])
cg.add(var.set_output(output_))
if CONF_OSCILLATION_OUTPUT in config:
oscillation_output = yield cg.get_variable(config[CONF_OSCILLATION_OUTPUT])
cg.add(var.set_oscillation(oscillation_output))

3
esphome/components/binary/fan/binary_fan.h
View File

@ -9,7 +9,8 @@ namespace binary {
class BinaryFan : public Component {
public:
BinaryFan(fan::FanState *fan, output::BinaryOutput *output) : fan_(fan), output_(output) {}
void set_fan(fan::FanState *fan) { fan_ = fan; }
void set_output(output::BinaryOutput *output) { output_ = output; }
void setup() override;
void loop() override;
void dump_config() override;

14
esphome/components/binary/light/__init__.py
View File

@ -6,13 +6,15 @@ from .. import binary_ns
BinaryLightOutput = binary_ns.class_('BinaryLightOutput', light.LightOutput)
CONFIG_SCHEMA = cv.nameable(light.BINARY_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_variable_id(BinaryLightOutput),
cv.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
}))
CONFIG_SCHEMA = light.BINARY_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(BinaryLightOutput),
cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
})
def to_code(config):
out = yield cg.get_variable(config[CONF_OUTPUT])
var = cg.new_Pvariable(config[CONF_OUTPUT_ID], out)
var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
yield light.register_light(var, config)
out = yield cg.get_variable(config[CONF_OUTPUT])
cg.add(var.set_output(out))

2
esphome/components/binary/light/binary_light_output.h
View File

@ -9,7 +9,7 @@ namespace binary {
class BinaryLightOutput : public light::LightOutput {
public:
BinaryLightOutput(output::BinaryOutput *output) : output_(output) {}
void set_output(output::BinaryOutput *output) { output_ = output; }
light::LightTraits get_traits() override {
auto traits = light::LightTraits();
traits.set_supports_brightness(false);

120
esphome/components/binary_sensor/__init__.py
View File

@ -1,16 +1,16 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation, core
from esphome.automation import CONDITION_REGISTRY, Condition, maybe_simple_id
from esphome.automation import Condition, maybe_simple_id
from esphome.components import mqtt
from esphome.const import CONF_DEVICE_CLASS, CONF_FILTERS, \
CONF_ID, CONF_INTERNAL, CONF_INVALID_COOLDOWN, CONF_INVERTED, \
CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_ON_CLICK, \
CONF_ON_DOUBLE_CLICK, CONF_ON_MULTI_CLICK, CONF_ON_PRESS, CONF_ON_RELEASE, CONF_ON_STATE, \
CONF_STATE, CONF_TIMING, CONF_TRIGGER_ID, CONF_FOR, CONF_VALUE, CONF_NAME, CONF_MQTT_ID
CONF_STATE, CONF_TIMING, CONF_TRIGGER_ID, CONF_FOR, CONF_NAME, CONF_MQTT_ID
from esphome.core import CORE, coroutine
from esphome.py_compat import string_types
from esphome.util import ServiceRegistry
from esphome.util import Registry
DEVICE_CLASSES = [
'', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
@ -26,15 +26,15 @@ BinarySensor = binary_sensor_ns.class_('BinarySensor', cg.Nameable)
BinarySensorPtr = BinarySensor.operator('ptr')
# Triggers
PressTrigger = binary_sensor_ns.class_('PressTrigger', cg.Trigger.template())
ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', cg.Trigger.template())
ClickTrigger = binary_sensor_ns.class_('ClickTrigger', cg.Trigger.template())
DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', cg.Trigger.template())
MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', cg.Trigger.template(),
PressTrigger = binary_sensor_ns.class_('PressTrigger', automation.Trigger.template())
ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', automation.Trigger.template())
ClickTrigger = binary_sensor_ns.class_('ClickTrigger', automation.Trigger.template())
DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', automation.Trigger.template())
MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', automation.Trigger.template(),
cg.Component)
MultiClickTriggerEvent = binary_sensor_ns.struct('MultiClickTriggerEvent')
StateTrigger = binary_sensor_ns.class_('StateTrigger', cg.Trigger.template(bool))
BinarySensorPublishAction = binary_sensor_ns.class_('BinarySensorPublishAction', cg.Action)
StateTrigger = binary_sensor_ns.class_('StateTrigger', automation.Trigger.template(bool))
BinarySensorPublishAction = binary_sensor_ns.class_('BinarySensorPublishAction', automation.Action)
# Condition
BinarySensorCondition = binary_sensor_ns.class_('BinarySensorCondition', Condition)
@ -46,55 +46,34 @@ DelayedOffFilter = binary_sensor_ns.class_('DelayedOffFilter', Filter, cg.Compon
InvertFilter = binary_sensor_ns.class_('InvertFilter', Filter)
LambdaFilter = binary_sensor_ns.class_('LambdaFilter', Filter)
FILTER_REGISTRY = ServiceRegistry()
validate_filters = cv.validate_registry('filter', FILTER_REGISTRY, [CONF_ID])
FILTER_REGISTRY = Registry()
validate_filters = cv.validate_registry('filter', FILTER_REGISTRY)
@FILTER_REGISTRY.register('invert',
cv.Schema({
cv.GenerateID(): cv.declare_variable_id(InvertFilter)
}))
def invert_filter_to_code(config):
rhs = InvertFilter.new()
var = cg.Pvariable(config[CONF_ID], rhs)
@FILTER_REGISTRY.register('invert', InvertFilter, {})
def invert_filter_to_code(config, filter_id):
yield cg.new_Pvariable(filter_id)
@FILTER_REGISTRY.register('delayed_on', DelayedOnFilter,
cv.positive_time_period_milliseconds)
def delayed_on_filter_to_code(config, filter_id):
var = cg.new_Pvariable(filter_id, config)
yield cg.register_component(var, {})
yield var
@FILTER_REGISTRY.register('delayed_on',
cv.maybe_simple_value(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DelayedOnFilter),
cv.Required(CONF_VALUE): cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA)))
def delayed_on_filter_to_code(config):
rhs = DelayedOnFilter.new(config[CONF_VALUE])
var = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(var, config)
@FILTER_REGISTRY.register('delayed_off', DelayedOffFilter, cv.positive_time_period_milliseconds)
def delayed_off_filter_to_code(config, filter_id):
var = cg.new_Pvariable(filter_id, config)
yield cg.register_component(var, {})
yield var
@FILTER_REGISTRY.register('delayed_off',
cv.maybe_simple_value(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DelayedOffFilter),
cv.Required(CONF_VALUE): cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA)))
def delayed_off_filter_to_code(config):
rhs = DelayedOffFilter.new(config[CONF_VALUE])
var = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(var, config)
yield var
@FILTER_REGISTRY.register('lambda',
cv.maybe_simple_value(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(LambdaFilter),
cv.Required(CONF_VALUE): cv.lambda_,
})))
def lambda_filter_to_code(config):
lambda_ = yield cg.process_lambda(config[CONF_VALUE], [(bool, 'x')],
return_type=cg.optional.template(bool))
rhs = LambdaFilter.new(lambda_)
var = cg.Pvariable(config[CONF_ID], rhs)
yield var
@FILTER_REGISTRY.register('lambda', LambdaFilter, cv.lambda_)
def lambda_filter_to_code(config, filter_id):
lambda_ = yield cg.process_lambda(config, [(bool, 'x')], return_type=cg.optional.template(bool))
yield cg.new_Pvariable(filter_id, lambda_)
MULTI_CLICK_TIMING_SCHEMA = cv.Schema({
@ -193,35 +172,35 @@ def validate_multi_click_timing(value):
device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space='_')
BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(BinarySensor),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_variable_id(mqtt.MQTTBinarySensorComponent),
cv.GenerateID(): cv.declare_id(BinarySensor),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTBinarySensorComponent),
cv.Optional(CONF_DEVICE_CLASS): device_class,
cv.Optional(CONF_FILTERS): validate_filters,
cv.Optional(CONF_ON_PRESS): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(PressTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PressTrigger),
}),
cv.Optional(CONF_ON_RELEASE): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ReleaseTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ReleaseTrigger),
}),
cv.Optional(CONF_ON_CLICK): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ClickTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ClickTrigger),
cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
}),
cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(DoubleClickTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DoubleClickTrigger),
cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
}),
cv.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MultiClickTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MultiClickTrigger),
cv.Required(CONF_TIMING): cv.All([parse_multi_click_timing_str],
validate_multi_click_timing),
cv.Optional(CONF_INVALID_COOLDOWN, default='1s'): cv.positive_time_period_milliseconds,
}),
cv.Optional(CONF_ON_STATE): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StateTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger),
}),
cv.Optional(CONF_INVERTED): cv.invalid(
@ -234,6 +213,7 @@ BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
@coroutine
def setup_binary_sensor_core_(var, config):
cg.add(var.set_name(config[CONF_NAME]))
if CONF_INTERNAL in config:
cg.add(var.set_internal(CONF_INTERNAL))
if CONF_DEVICE_CLASS in config:
@ -300,26 +280,24 @@ def new_binary_sensor(config):
yield var
BINARY_SENSOR_IS_ON_OFF_CONDITION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(BinarySensor),
BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(BinarySensor),
cv.Optional(CONF_FOR): cv.positive_time_period_milliseconds,
})
@CONDITION_REGISTRY.register('binary_sensor.is_on', BINARY_SENSOR_IS_ON_OFF_CONDITION_SCHEMA)
@automation.register_condition('binary_sensor.is_on', BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = BinarySensorCondition.template(template_arg)
rhs = type.new(var, True, config.get(CONF_FOR))
yield cg.Pvariable(condition_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(condition_id, template_arg, paren, True, config.get(CONF_FOR))
@CONDITION_REGISTRY.register('binary_sensor.is_off', BINARY_SENSOR_IS_ON_OFF_CONDITION_SCHEMA)
@automation.register_condition('binary_sensor.is_off', BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = BinarySensorCondition.template(template_arg)
rhs = type.new(var, False, config.get(CONF_FOR))
yield cg.Pvariable(condition_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(condition_id, template_arg, paren, False, config.get(CONF_FOR))
def to_code(config):

1
esphome/components/binary_sensor/automation.h
View File

@ -150,7 +150,6 @@ template<typename... Ts> class BinarySensorPublishAction : public Action<Ts...>
void play(Ts... x) override {
auto val = this->state_.value(x...);
this->sensor_->publish_state(val);
this->play_next(x...);
}
protected:

2
esphome/components/binary_sensor/binary_sensor.h
View File

@ -24,12 +24,12 @@ namespace binary_sensor {
*/
class BinarySensor : public Nameable {
public:
explicit BinarySensor();
/** Construct a binary sensor with the specified name
*
* @param name Name of this binary sensor.
*/
explicit BinarySensor(const std::string &name);
explicit BinarySensor();
/** Add a callback to be notified of state changes.
*

6
esphome/components/ble_presence/binary_sensor.py
View File

@ -11,10 +11,10 @@ ble_presence_ns = cg.esphome_ns.namespace('ble_presence')
BLEPresenceDevice = ble_presence_ns.class_('BLEPresenceDevice', binary_sensor.BinarySensor,
cg.Component, ESPBTDeviceListener)
CONFIG_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(BLEPresenceDevice),
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(BLEPresenceDevice),
cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
}).extend(ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA))
}).extend(ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
def to_code(config):

13
esphome/components/ble_rssi/sensor.py
View File

@ -3,8 +3,7 @@ import esphome.config_validation as cv
from esphome.components import sensor
from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESPBTDeviceListener, \
ESP_BLE_DEVICE_SCHEMA
from esphome.const import CONF_MAC_ADDRESS, CONF_NAME, CONF_ID, CONF_UNIT_OF_MEASUREMENT, \
CONF_ICON, CONF_ACCURACY_DECIMALS, UNIT_DECIBEL, ICON_SIGNAL
from esphome.const import CONF_MAC_ADDRESS, CONF_NAME, CONF_ID, UNIT_DECIBEL, ICON_SIGNAL
DEPENDENCIES = ['esp32_ble_tracker']
@ -12,14 +11,10 @@ ble_rssi_ns = cg.esphome_ns.namespace('ble_rssi')
BLERSSISensor = ble_rssi_ns.class_('BLERSSISensor', sensor.Sensor, cg.Component,
ESPBTDeviceListener)
CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(BLERSSISensor),
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_DECIBEL, ICON_SIGNAL, 0).extend({
cv.GenerateID(): cv.declare_id(BLERSSISensor),
cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_DECIBEL): sensor.unit_of_measurement,
cv.Optional(CONF_ICON, default=ICON_SIGNAL): sensor.icon,
cv.Optional(CONF_ACCURACY_DECIMALS, default=0): sensor.accuracy_decimals
}).extend(ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA))
}).extend(ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
def to_code(config):

2
esphome/components/bme280/bme280.h
View File

@ -60,8 +60,6 @@ enum BME280IIRFilter {
/// This class implements support for the BME280 Temperature+Pressure+Humidity i2c sensor.
class BME280Component : public PollingComponent, public i2c::I2CDevice {
public:
BME280Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }
void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }

37
esphome/components/bme280/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_OVERSAMPLING, \
CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, ICON_THERMOMETER, \
CONF_PRESSURE, CONF_TEMPERATURE, ICON_THERMOMETER, \
UNIT_CELSIUS, UNIT_HECTOPASCAL, ICON_GAUGE, ICON_WATER_PERCENT, UNIT_PERCENT
DEPENDENCIES = ['i2c']
@ -30,29 +30,28 @@ IIR_FILTER_OPTIONS = {
BME280Component = bme280_ns.class_('BME280Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(BME280Component),
cv.Optional(CONF_TEMPERATURE): cv.nameable(
cv.GenerateID(): cv.declare_id(BME280Component),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_PRESSURE): cv.nameable(
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_HUMIDITY): cv.nameable(
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x77))
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x77))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
@ -60,18 +59,18 @@ def to_code(config):
conf = config[CONF_TEMPERATURE]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_temperature_sensor(sens))
cg.add(var.set_temperature_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING]))
if CONF_PRESSURE in config:
conf = config[CONF_PRESSURE]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_pressure_sensor(sens))
cg.add(var.set_pressure_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_pressure_oversampling(conf[CONF_OVERSAMPLING]))
if CONF_HUMIDITY in config:
conf = config[CONF_HUMIDITY]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_humidity_sensor(sens))
cg.add(var.set_humidity_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_humidity_oversampling(conf[CONF_OVERSAMPLING]))
cg.add(var.set_iir_filter(IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]))
cg.add(var.set_iir_filter(config[CONF_IIR_FILTER]))

2
esphome/components/bme680/bme680.h
View File

@ -68,8 +68,6 @@ struct BME680CalibrationData {
class BME680Component : public PollingComponent, public i2c::I2CDevice {
public:
BME680Component(uint32_t update_interval) : PollingComponent(update_interval) {}
/// Set the temperature oversampling value. Defaults to 16X.
void set_temperature_oversampling(BME680Oversampling temperature_oversampling);
/// Set the pressure oversampling value. Defaults to 16X.

43
esphome/components/bme680/sensor.py
View File

@ -4,7 +4,7 @@ from esphome import core
from esphome.components import i2c, sensor
from esphome.const import CONF_DURATION, CONF_GAS_RESISTANCE, CONF_HEATER, \
CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_OVERSAMPLING, CONF_PRESSURE, \
CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, UNIT_OHM, ICON_GAS_CYLINDER, UNIT_CELSIUS, \
CONF_TEMPERATURE, UNIT_OHM, ICON_GAS_CYLINDER, UNIT_CELSIUS, \
ICON_THERMOMETER, UNIT_HECTOPASCAL, ICON_GAUGE, ICON_WATER_PERCENT, UNIT_PERCENT
DEPENDENCIES = ['i2c']
@ -35,36 +35,35 @@ IIR_FILTER_OPTIONS = {
BME680Component = bme680_ns.class_('BME680Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(BME680Component),
cv.Optional(CONF_TEMPERATURE): cv.nameable(
cv.GenerateID(): cv.declare_id(BME680Component),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_PRESSURE): cv.nameable(
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_HUMIDITY): cv.nameable(
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_GAS_RESISTANCE): cv.nameable(
sensor.sensor_schema(UNIT_OHM, ICON_GAS_CYLINDER, 1)),
cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_GAS_RESISTANCE):
sensor.sensor_schema(UNIT_OHM, ICON_GAS_CYLINDER, 1),
cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True),
cv.Optional(CONF_HEATER): cv.Any(None, cv.All(cv.Schema({
cv.Optional(CONF_TEMPERATURE, default=320): cv.All(cv.Coerce(int), cv.Range(200, 400)),
cv.Optional(CONF_TEMPERATURE, default=320): cv.int_range(min=200, max=400),
cv.Optional(CONF_DURATION, default='150ms'): cv.All(
cv.positive_time_period_milliseconds, cv.Range(max=core.TimePeriod(milliseconds=4032)))
}, cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION)))),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x76))
}), cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION))),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x76))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
@ -72,19 +71,19 @@ def to_code(config):
conf = config[CONF_TEMPERATURE]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_temperature_sensor(sens))
cg.add(var.set_temperature_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING]))
if CONF_PRESSURE in config:
conf = config[CONF_PRESSURE]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_pressure_sensor(sens))
cg.add(var.set_pressure_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_pressure_oversampling(conf[CONF_OVERSAMPLING]))
if CONF_HUMIDITY in config:
conf = config[CONF_HUMIDITY]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_humidity_sensor(sens))
cg.add(var.set_humidity_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_humidity_oversampling(conf[CONF_OVERSAMPLING]))
if CONF_GAS_RESISTANCE in config:
conf = config[CONF_GAS_RESISTANCE]

2
esphome/components/bmp085/bmp085.h
View File

@ -9,8 +9,6 @@ namespace bmp085 {
class BMP085Component : public PollingComponent, public i2c::I2CDevice {
public:
BMP085Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
void set_pressure(sensor::Sensor *pressure) { pressure_ = pressure; }

15
esphome/components/bmp085/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_ID, CONF_PRESSURE, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, UNIT_CELSIUS, ICON_THERMOMETER, ICON_GAUGE, UNIT_HECTOPASCAL
UNIT_CELSIUS, ICON_THERMOMETER, ICON_GAUGE, UNIT_HECTOPASCAL
DEPENDENCIES = ['i2c']
@ -10,17 +10,14 @@ bmp085_ns = cg.esphome_ns.namespace('bmp085')
BMP085Component = bmp085_ns.class_('BMP085Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(BMP085Component),
cv.Optional(CONF_TEMPERATURE):
cv.nameable(sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1)),
cv.Optional(CONF_PRESSURE):
cv.nameable(sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x77))
cv.GenerateID(): cv.declare_id(BMP085Component),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_PRESSURE): sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x77))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

1
esphome/components/bmp280/bmp280.cpp
View File

@ -233,7 +233,6 @@ uint16_t BMP280Component::read_u16_le_(uint8_t a_register) {
return (data >> 8) | (data << 8);
}
int16_t BMP280Component::read_s16_le_(uint8_t a_register) { return this->read_u16_le_(a_register); }
BMP280Component::BMP280Component(uint32_t update_interval) : PollingComponent(update_interval) {}
} // namespace bmp280
} // namespace esphome

1
esphome/components/bmp280/bmp280.h
View File

@ -53,7 +53,6 @@ enum BMP280IIRFilter {
/// This class implements support for the BMP280 Temperature+Pressure i2c sensor.
class BMP280Component : public PollingComponent, public i2c::I2CDevice {
public:
BMP280Component(uint32_t update_interval);
void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }

31
esphome/components/bmp280/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_ID, CONF_PRESSURE, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, UNIT_CELSIUS, ICON_THERMOMETER, ICON_GAUGE, UNIT_HECTOPASCAL, \
UNIT_CELSIUS, ICON_THERMOMETER, ICON_GAUGE, UNIT_HECTOPASCAL, \
CONF_IIR_FILTER, CONF_OVERSAMPLING
DEPENDENCIES = ['i2c']
@ -30,24 +30,19 @@ IIR_FILTER_OPTIONS = {
BMP280Component = bmp280_ns.class_('BMP280Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(BMP280Component),
cv.Optional(CONF_TEMPERATURE): cv.nameable(
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_PRESSURE): cv.nameable(
sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})),
cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x77))
cv.GenerateID(): cv.declare_id(BMP280Component),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_PRESSURE): sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x77))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
@ -55,10 +50,10 @@ def to_code(config):
conf = config[CONF_TEMPERATURE]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_temperature_sensor(sens))
cg.add(var.set_temperature_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING]))
if CONF_PRESSURE in config:
conf = config[CONF_PRESSURE]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_pressure_sensor(sens))
cg.add(var.set_pressure_oversampling(OVERSAMPLING_OPTIONS[conf[CONF_OVERSAMPLING]]))
cg.add(var.set_pressure_oversampling(conf[CONF_OVERSAMPLING]))

40
esphome/components/climate/__init__.py
View File

@ -1,13 +1,15 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.automation import ACTION_REGISTRY
from esphome import automation
from esphome.components import mqtt
from esphome.const import CONF_AWAY, CONF_ID, CONF_INTERNAL, CONF_MAX_TEMPERATURE, \
CONF_MIN_TEMPERATURE, CONF_MODE, CONF_TARGET_TEMPERATURE, \
CONF_TARGET_TEMPERATURE_HIGH, CONF_TARGET_TEMPERATURE_LOW, CONF_TEMPERATURE_STEP, CONF_VISUAL, \
CONF_MQTT_ID
CONF_MQTT_ID, CONF_NAME
from esphome.core import CORE, coroutine
IS_PLATFORM_COMPONENT = True
climate_ns = cg.esphome_ns.namespace('climate')
ClimateDevice = climate_ns.class_('Climate', cg.Nameable)
@ -23,14 +25,14 @@ CLIMATE_MODES = {
'HEAT': ClimateMode.CLIMATE_MODE_HEAT,
}
validate_climate_mode = cv.one_of(*CLIMATE_MODES, upper=True)
validate_climate_mode = cv.enum(CLIMATE_MODES, upper=True)
# Actions
ControlAction = climate_ns.class_('ControlAction', cg.Action)
ControlAction = climate_ns.class_('ControlAction', automation.Action)
CLIMATE_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(ClimateDevice),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_variable_id(mqtt.MQTTClimateComponent),
cv.GenerateID(): cv.declare_id(ClimateDevice),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTClimateComponent),
cv.Optional(CONF_VISUAL, default={}): cv.Schema({
cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature,
cv.Optional(CONF_MAX_TEMPERATURE): cv.temperature,
@ -42,6 +44,7 @@ CLIMATE_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
@coroutine
def setup_climate_core_(var, config):
cg.add(var.set_name(config[CONF_NAME]))
if CONF_INTERNAL in config:
cg.add(var.set_internal(config[CONF_INTERNAL]))
visual = config[CONF_VISUAL]
@ -66,7 +69,7 @@ def register_climate(var, config):
CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.use_variable_id(ClimateDevice),
cv.Required(CONF_ID): cv.use_id(ClimateDevice),
cv.Optional(CONF_MODE): cv.templatable(validate_climate_mode),
cv.Optional(CONF_TARGET_TEMPERATURE): cv.templatable(cv.temperature),
cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.templatable(cv.temperature),
@ -75,29 +78,26 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema({
})
@ACTION_REGISTRY.register('climate.control', CLIMATE_CONTROL_ACTION_SCHEMA)
@automation.register_action('climate.control', ControlAction, CLIMATE_CONTROL_ACTION_SCHEMA)
def climate_control_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = ControlAction.template(template_arg)
rhs = type.new(var)
action = cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_MODE in config:
template_ = yield cg.templatable(config[CONF_MODE], args, ClimateMode,
to_exp=CLIMATE_MODES)
cg.add(action.set_mode(template_))
template_ = yield cg.templatable(config[CONF_MODE], args, ClimateMode)
cg.add(var.set_mode(template_))
if CONF_TARGET_TEMPERATURE in config:
template_ = yield cg.templatable(config[CONF_TARGET_TEMPERATURE], args, float)
cg.add(action.set_target_temperature(template_))
cg.add(var.set_target_temperature(template_))
if CONF_TARGET_TEMPERATURE_LOW in config:
template_ = yield cg.templatable(config[CONF_TARGET_TEMPERATURE_LOW], args, float)
cg.add(action.set_target_temperature_low(template_))
cg.add(var.set_target_temperature_low(template_))
if CONF_TARGET_TEMPERATURE_HIGH in config:
template_ = yield cg.templatable(config[CONF_TARGET_TEMPERATURE_HIGH], args, float)
cg.add(action.set_target_temperature_high(template_))
cg.add(var.set_target_temperature_high(template_))
if CONF_AWAY in config:
template_ = yield cg.templatable(config[CONF_AWAY], args, bool)
cg.add(action.set_away(template_))
yield action
cg.add(var.set_away(template_))
yield var
def to_code(config):

4
esphome/components/climate/climate.h
View File

@ -114,10 +114,10 @@ struct ClimateDeviceRestoreState {
*/
class Climate : public Nameable {
public:
/// Construct a climate device with a name.
Climate(const std::string &name);
/// Construct a climate device with empty name (will be set later).
Climate();
/// Construct a climate device with a name.
Climate(const std::string &name);
/// The active mode of the climate device.
ClimateMode mode{CLIMATE_MODE_OFF};

75
esphome/components/cover/__init__.py
View File

@ -1,9 +1,10 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.automation import ACTION_REGISTRY, maybe_simple_id, Condition
from esphome import automation
from esphome.automation import maybe_simple_id, Condition
from esphome.components import mqtt
from esphome.const import CONF_ID, CONF_INTERNAL, CONF_DEVICE_CLASS, CONF_STATE, \
CONF_POSITION, CONF_TILT, CONF_STOP, CONF_MQTT_ID
CONF_POSITION, CONF_TILT, CONF_STOP, CONF_MQTT_ID, CONF_NAME
from esphome.core import CORE, coroutine
IS_PLATFORM_COMPONENT = True
@ -24,7 +25,7 @@ COVER_STATES = {
'OPEN': COVER_OPEN,
'CLOSED': COVER_CLOSED,
}
validate_cover_state = cv.one_of(*COVER_STATES, upper=True)
validate_cover_state = cv.enum(COVER_STATES, upper=True)
CoverOperation = cover_ns.enum('CoverOperation')
COVER_OPERATIONS = {
@ -32,20 +33,20 @@ COVER_OPERATIONS = {
'OPENING': CoverOperation.COVER_OPERATION_OPENING,
'CLOSING': CoverOperation.COVER_OPERATION_CLOSING,
}
validate_cover_operation = cv.one_of(*COVER_OPERATIONS, upper=True)
validate_cover_operation = cv.enum(COVER_OPERATIONS, upper=True)
# Actions
OpenAction = cover_ns.class_('OpenAction', cg.Action)
CloseAction = cover_ns.class_('CloseAction', cg.Action)
StopAction = cover_ns.class_('StopAction', cg.Action)
ControlAction = cover_ns.class_('ControlAction', cg.Action)
CoverPublishAction = cover_ns.class_('CoverPublishAction', cg.Action)
OpenAction = cover_ns.class_('OpenAction', automation.Action)
CloseAction = cover_ns.class_('CloseAction', automation.Action)
StopAction = cover_ns.class_('StopAction', automation.Action)
ControlAction = cover_ns.class_('ControlAction', automation.Action)
CoverPublishAction = cover_ns.class_('CoverPublishAction', automation.Action)
CoverIsOpenCondition = cover_ns.class_('CoverIsOpenCondition', Condition)
CoverIsClosedCondition = cover_ns.class_('CoverIsClosedCondition', Condition)
COVER_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(Cover),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_variable_id(mqtt.MQTTCoverComponent),
cv.GenerateID(): cv.declare_id(Cover),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTCoverComponent),
cv.Optional(CONF_DEVICE_CLASS): cv.one_of(*DEVICE_CLASSES, lower=True),
# TODO: MQTT topic options
})
@ -53,6 +54,7 @@ COVER_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
@coroutine
def setup_cover_core_(var, config):
cg.add(var.set_name(config[CONF_NAME]))
if CONF_INTERNAL in config:
cg.add(var.set_internal(config[CONF_INTERNAL]))
if CONF_DEVICE_CLASS in config:
@ -72,63 +74,54 @@ def register_cover(var, config):
COVER_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(Cover),
cv.Required(CONF_ID): cv.use_id(Cover),
})
@ACTION_REGISTRY.register('cover.open', COVER_ACTION_SCHEMA)
@automation.register_action('cover.open', OpenAction, COVER_ACTION_SCHEMA)
def cover_open_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = OpenAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@ACTION_REGISTRY.register('cover.close', COVER_ACTION_SCHEMA)
@automation.register_action('cover.close', CloseAction, COVER_ACTION_SCHEMA)
def cover_close_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = CloseAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@ACTION_REGISTRY.register('cover.stop', COVER_ACTION_SCHEMA)
@automation.register_action('cover.stop', StopAction, COVER_ACTION_SCHEMA)
def cover_stop_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = StopAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
COVER_CONTROL_ACTION_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.use_variable_id(Cover),
cv.Required(CONF_ID): cv.use_id(Cover),
cv.Optional(CONF_STOP): cv.templatable(cv.boolean),
cv.Exclusive(CONF_STATE, 'pos'): cv.templatable(cv.one_of(*COVER_STATES)),
cv.Exclusive(CONF_STATE, 'pos'): cv.templatable(validate_cover_state),
cv.Exclusive(CONF_POSITION, 'pos'): cv.templatable(cv.percentage),
cv.Optional(CONF_TILT): cv.templatable(cv.percentage),
})
@ACTION_REGISTRY.register('cover.control', COVER_CONTROL_ACTION_SCHEMA)
@automation.register_action('cover.control', ControlAction, COVER_CONTROL_ACTION_SCHEMA)
def cover_control_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = StopAction.template(template_arg)
rhs = type.new(var)
action = cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_STOP in config:
template_ = yield cg.templatable(config[CONF_STOP], args, bool)
cg.add(action.set_stop(template_))
cg.add(var.set_stop(template_))
if CONF_STATE in config:
template_ = yield cg.templatable(config[CONF_STATE], args, float,
to_exp=COVER_STATES)
cg.add(action.set_position(template_))
template_ = yield cg.templatable(config[CONF_STATE], args, float)
cg.add(var.set_position(template_))
if CONF_POSITION in config:
template_ = yield cg.templatable(config[CONF_POSITION], args, float)
cg.add(action.set_position(template_))
cg.add(var.set_position(template_))
if CONF_TILT in config:
template_ = yield cg.templatable(config[CONF_TILT], args, float)
cg.add(action.set_tilt(template_))
yield action
cg.add(var.set_tilt(template_))
yield var
def to_code(config):

17
esphome/components/cover/automation.h
View File

@ -11,10 +11,7 @@ template<typename... Ts> class OpenAction : public Action<Ts...> {
public:
explicit OpenAction(Cover *cover) : cover_(cover) {}
void play(Ts... x) override {
this->cover_->open();
this->play_next(x...);
}
void play(Ts... x) override { this->cover_->open(); }
protected:
Cover *cover_;
@ -24,10 +21,7 @@ template<typename... Ts> class CloseAction : public Action<Ts...> {
public:
explicit CloseAction(Cover *cover) : cover_(cover) {}
void play(Ts... x) override {
this->cover_->close();
this->play_next(x...);
}
void play(Ts... x) override { this->cover_->close(); }
protected:
Cover *cover_;
@ -37,10 +31,7 @@ template<typename... Ts> class StopAction : public Action<Ts...> {
public:
explicit StopAction(Cover *cover) : cover_(cover) {}
void play(Ts... x) override {
this->cover_->stop();
this->play_next(x...);
}
void play(Ts... x) override { this->cover_->stop(); }
protected:
Cover *cover_;
@ -59,7 +50,6 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
if (this->tilt_.has_value())
call.set_tilt(this->tilt_.value(x...));
call.perform();
this->play_next(x...);
}
TEMPLATABLE_VALUE(bool, stop)
@ -81,7 +71,6 @@ template<typename... Ts> class CoverPublishAction : public Action<Ts...> {
if (this->current_operation_.has_value())
this->cover_->current_operation = this->current_operation_.value(x...);
this->cover_->publish_state();
this->play_next(x...);
}
TEMPLATABLE_VALUE(float, position)

2
esphome/components/cover/cover.h
View File

@ -105,8 +105,8 @@ const char *cover_operation_to_str(CoverOperation op);
*/
class Cover : public Nameable {
public:
explicit Cover(const std::string &name);
explicit Cover();
explicit Cover(const std::string &name);
/// The current operation of the cover (idle, opening, closing).
CoverOperation current_operation{COVER_OPERATION_IDLE};

2
esphome/components/cse7766/cse7766.h
View File

@ -9,8 +9,6 @@ namespace cse7766 {
class CSE7766Component : public PollingComponent, public uart::UARTDevice {
public:
CSE7766Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
void set_current_sensor(sensor::Sensor *current_sensor) { current_sensor_ = current_sensor; }
void set_power_sensor(sensor::Sensor *power_sensor) { power_sensor_ = power_sensor; }

16
esphome/components/cse7766/sensor.py
View File

@ -1,7 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor, uart
from esphome.const import CONF_CURRENT, CONF_ID, CONF_POWER, CONF_UPDATE_INTERVAL, CONF_VOLTAGE, \
from esphome.const import CONF_CURRENT, CONF_ID, CONF_POWER, CONF_VOLTAGE, \
UNIT_VOLT, ICON_FLASH, UNIT_AMPERE, UNIT_WATT
DEPENDENCIES = ['uart']
@ -10,18 +10,16 @@ cse7766_ns = cg.esphome_ns.namespace('cse7766')
CSE7766Component = cse7766_ns.class_('CSE7766Component', cg.PollingComponent, uart.UARTDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CSE7766Component),
cv.GenerateID(): cv.declare_id(CSE7766Component),
cv.Optional(CONF_VOLTAGE): cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1)),
cv.Optional(CONF_CURRENT): cv.nameable(
sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2)),
cv.Optional(CONF_POWER): cv.nameable(sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(uart.UART_DEVICE_SCHEMA)
cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
}).extend(cv.polling_component_schema('60s')).extend(uart.UART_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield uart.register_uart_device(var, config)

12
esphome/components/custom/binary_sensor/__init__.py
View File

@ -1,16 +1,15 @@
from esphome.components import binary_sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA, CONF_NAME
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA
from .. import custom_ns
CustomBinarySensorConstructor = custom_ns.class_('CustomBinarySensorConstructor')
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomBinarySensorConstructor),
cv.GenerateID(): cv.declare_id(CustomBinarySensorConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_BINARY_SENSORS):
cv.ensure_list(cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA)),
cv.Required(CONF_BINARY_SENSORS): cv.ensure_list(binary_sensor.BINARY_SENSOR_SCHEMA),
})
@ -22,5 +21,4 @@ def to_code(config):
custom = cg.variable(config[CONF_ID], rhs)
for i, conf in enumerate(config[CONF_BINARY_SENSORS]):
rhs = custom.Pget_binary_sensor(i)
cg.add(rhs.set_name(conf[CONF_NAME]))
yield binary_sensor.register_binary_sensor(rhs, conf)

8
esphome/components/custom/output/__init__.py
View File

@ -8,22 +8,22 @@ CustomBinaryOutputConstructor = custom_ns.class_('CustomBinaryOutputConstructor'
CustomFloatOutputConstructor = custom_ns.class_('CustomFloatOutputConstructor')
BINARY_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomBinaryOutputConstructor),
cv.GenerateID(): cv.declare_id(CustomBinaryOutputConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_TYPE): 'binary',
cv.Required(CONF_OUTPUTS):
cv.ensure_list(output.BINARY_OUTPUT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(output.BinaryOutput),
cv.GenerateID(): cv.declare_id(output.BinaryOutput),
})),
})
FLOAT_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomFloatOutputConstructor),
cv.GenerateID(): cv.declare_id(CustomFloatOutputConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_TYPE): 'float',
cv.Required(CONF_OUTPUTS):
cv.ensure_list(output.FLOAT_OUTPUT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(output.FloatOutput),
cv.GenerateID(): cv.declare_id(output.FloatOutput),
})),
})

10
esphome/components/custom/sensor/__init__.py
View File

@ -1,17 +1,15 @@
from esphome.components import sensor
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_SENSORS
from .. import custom_ns
CustomSensorConstructor = custom_ns.class_('CustomSensorConstructor')
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomSensorConstructor),
cv.GenerateID(): cv.declare_id(CustomSensorConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_SENSORS): cv.ensure_list(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
})),
cv.Required(CONF_SENSORS): cv.ensure_list(sensor.SENSOR_SCHEMA),
})

4
esphome/components/custom/switch/__init__.py
View File

@ -8,11 +8,11 @@ from .. import custom_ns
CustomSwitchConstructor = custom_ns.class_('CustomSwitchConstructor')
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomSwitchConstructor),
cv.GenerateID(): cv.declare_id(CustomSwitchConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_SWITCHES):
cv.ensure_list(switch.SWITCH_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(switch.Switch),
cv.GenerateID(): cv.declare_id(switch.Switch),
})),
})

4
esphome/components/custom/text_sensor/__init__.py
View File

@ -7,11 +7,11 @@ from .. import custom_ns
CustomTextSensorConstructor = custom_ns.class_('CustomTextSensorConstructor')
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomTextSensorConstructor),
cv.GenerateID(): cv.declare_id(CustomTextSensorConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Required(CONF_TEXT_SENSORS):
cv.ensure_list(text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(text_sensor.TextSensor),
cv.GenerateID(): cv.declare_id(text_sensor.TextSensor),
})),
})

4
esphome/components/custom_component/__init__.py
View File

@ -7,10 +7,10 @@ CustomComponentConstructor = custom_component_ns.class_('CustomComponentConstruc
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(CustomComponentConstructor),
cv.GenerateID(): cv.declare_id(CustomComponentConstructor),
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Optional(CONF_COMPONENTS): cv.ensure_list(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(cg.Component)
cv.GenerateID(): cv.declare_id(cg.Component)
}).extend(cv.COMPONENT_SCHEMA)),
})

10
esphome/components/cwww/cwww_light_output.h
View File

@ -9,12 +9,10 @@ namespace cwww {
class CWWWLightOutput : public light::LightOutput {
public:
CWWWLightOutput(output::FloatOutput *cold_white, output::FloatOutput *warm_white, float cold_white_temperature,
float warm_white_temperature)
: cold_white_(cold_white),
warm_white_(warm_white),
cold_white_temperature_(cold_white_temperature),
warm_white_temperature_(warm_white_temperature) {}
void set_cold_white(output::FloatOutput *cold_white) { cold_white_ = cold_white; }
void set_warm_white(output::FloatOutput *warm_white) { warm_white_ = warm_white; }
void set_cold_white_temperature(float cold_white_temperature) { cold_white_temperature_ = cold_white_temperature; }
void set_warm_white_temperature(float warm_white_temperature) { warm_white_temperature_ = warm_white_temperature; }
light::LightTraits get_traits() override {
auto traits = light::LightTraits();
traits.set_supports_brightness(true);

23
esphome/components/cwww/light.py
View File

@ -7,19 +7,22 @@ from esphome.const import CONF_OUTPUT_ID, CONF_COLD_WHITE, CONF_WARM_WHITE, \
cwww_ns = cg.esphome_ns.namespace('cwww')
CWWWLightOutput = cwww_ns.class_('CWWWLightOutput', light.LightOutput)
CONFIG_SCHEMA = cv.nameable(light.RGB_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_variable_id(CWWWLightOutput),
cv.Required(CONF_COLD_WHITE): cv.use_variable_id(output.FloatOutput),
cv.Required(CONF_WARM_WHITE): cv.use_variable_id(output.FloatOutput),
CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(CWWWLightOutput),
cv.Required(CONF_COLD_WHITE): cv.use_id(output.FloatOutput),
cv.Required(CONF_WARM_WHITE): cv.use_id(output.FloatOutput),
cv.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
cv.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
}))
})
def to_code(config):
cwhite = yield cg.get_variable(config[CONF_COLD_WHITE])
wwhite = yield cg.get_variable(config[CONF_WARM_WHITE])
var = cg.new_Pvariable(config[CONF_OUTPUT_ID], cwhite, wwhite,
config[CONF_COLD_WHITE_COLOR_TEMPERATURE],
config[CONF_WARM_WHITE_COLOR_TEMPERATURE])
var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
yield light.register_light(var, config)
cwhite = yield cg.get_variable(config[CONF_COLD_WHITE])
cg.add(var.set_cold_white(cwhite))
cg.add(var.set_cold_white_temperature(config[CONF_COLD_WHITE_COLOR_TEMPERATURE]))
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]))

11
esphome/components/dallas/__init__.py
View File

@ -1,7 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
from esphome.const import CONF_ID, CONF_PIN
MULTI_CONF = True
AUTO_LOAD = ['sensor']
@ -12,15 +12,14 @@ DallasComponent = dallas_ns.class_('DallasComponent', cg.PollingComponent)
ESPOneWire = dallas_ns.class_('ESPOneWire')
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DallasComponent),
cv.GenerateID(CONF_ONE_WIRE_ID): cv.declare_variable_id(ESPOneWire),
cv.GenerateID(): cv.declare_id(DallasComponent),
cv.GenerateID(CONF_ONE_WIRE_ID): cv.declare_id(ESPOneWire),
cv.Required(CONF_PIN): pins.gpio_input_pin_schema,
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA)
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
one_wire = cg.new_Pvariable(config[CONF_ONE_WIRE_ID], pin)
var = cg.new_Pvariable(config[CONF_ID], one_wire, config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID], one_wire)
yield cg.register_component(var, config)

18
esphome/components/dallas/dallas_component.cpp
View File

@ -95,15 +95,13 @@ void DallasComponent::dump_config() {
}
}
DallasTemperatureSensor *DallasComponent::get_sensor_by_address(const std::string &name, uint64_t address,
uint8_t resolution) {
auto s = new DallasTemperatureSensor(name, address, resolution, this);
DallasTemperatureSensor *DallasComponent::get_sensor_by_address(uint64_t address, uint8_t resolution) {
auto s = new DallasTemperatureSensor(address, resolution, this);
this->sensors_.push_back(s);
return s;
}
DallasTemperatureSensor *DallasComponent::get_sensor_by_index(const std::string &name, uint8_t index,
uint8_t resolution) {
auto s = this->get_sensor_by_address(name, 0, resolution);
DallasTemperatureSensor *DallasComponent::get_sensor_by_index(uint8_t index, uint8_t resolution) {
auto s = this->get_sensor_by_address(0, resolution);
s->set_index(index);
return s;
}
@ -148,12 +146,10 @@ void DallasComponent::update() {
});
}
}
DallasComponent::DallasComponent(ESPOneWire *one_wire, uint32_t update_interval)
: PollingComponent(update_interval), one_wire_(one_wire) {}
DallasComponent::DallasComponent(ESPOneWire *one_wire) : one_wire_(one_wire) {}
DallasTemperatureSensor::DallasTemperatureSensor(const std::string &name, uint64_t address, uint8_t resolution,
DallasComponent *parent)
: sensor::Sensor(name), parent_(parent) {
DallasTemperatureSensor::DallasTemperatureSensor(uint64_t address, uint8_t resolution, DallasComponent *parent)
: parent_(parent) {
this->set_address(address);
this->set_resolution(resolution);
}

8
esphome/components/dallas/dallas_component.h
View File

@ -11,10 +11,10 @@ class DallasTemperatureSensor;
class DallasComponent : public PollingComponent {
public:
explicit DallasComponent(ESPOneWire *one_wire, uint32_t update_interval);
explicit DallasComponent(ESPOneWire *one_wire);
DallasTemperatureSensor *get_sensor_by_address(const std::string &name, uint64_t address, uint8_t resolution);
DallasTemperatureSensor *get_sensor_by_index(const std::string &name, uint8_t index, uint8_t resolution);
DallasTemperatureSensor *get_sensor_by_address(uint64_t address, uint8_t resolution);
DallasTemperatureSensor *get_sensor_by_index(uint8_t index, uint8_t resolution);
void setup() override;
void dump_config() override;
@ -33,7 +33,7 @@ class DallasComponent : public PollingComponent {
/// Internal class that helps us create multiple sensors for one Dallas hub.
class DallasTemperatureSensor : public sensor::Sensor {
public:
DallasTemperatureSensor(const std::string &name, uint64_t address, uint8_t resolution, DallasComponent *parent);
DallasTemperatureSensor(uint64_t address, uint8_t resolution, DallasComponent *parent);
/// Helper to get a pointer to the address as uint8_t.
uint8_t *get_address8();

20
esphome/components/dallas/sensor.py
View File

@ -1,24 +1,19 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
CONF_RESOLUTION, CONF_UNIT_OF_MEASUREMENT, UNIT_CELSIUS, CONF_ICON, ICON_THERMOMETER, \
CONF_ACCURACY_DECIMALS, CONF_ID
from esphome.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_RESOLUTION, UNIT_CELSIUS, \
ICON_THERMOMETER, CONF_ID
from . import DallasComponent, dallas_ns
DallasTemperatureSensor = dallas_ns.class_('DallasTemperatureSensor', sensor.Sensor)
CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(DallasTemperatureSensor),
cv.GenerateID(CONF_DALLAS_ID): cv.use_variable_id(DallasComponent),
CONFIG_SCHEMA = cv.All(sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.GenerateID(): cv.declare_id(DallasTemperatureSensor),
cv.GenerateID(CONF_DALLAS_ID): cv.use_id(DallasComponent),
cv.Optional(CONF_ADDRESS): cv.hex_int,
cv.Optional(CONF_INDEX): cv.positive_int,
cv.Optional(CONF_RESOLUTION, default=12): cv.All(cv.int_, cv.Range(min=9, max=12)),
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_CELSIUS): sensor.unit_of_measurement,
cv.Optional(CONF_ICON, default=ICON_THERMOMETER): sensor.icon,
cv.Optional(CONF_ACCURACY_DECIMALS, default=1): sensor.accuracy_decimals,
}), cv.has_exactly_one_key(CONF_ADDRESS, CONF_INDEX))
@ -26,9 +21,8 @@ def to_code(config):
hub = yield cg.get_variable(config[CONF_DALLAS_ID])
if CONF_ADDRESS in config:
address = config[CONF_ADDRESS]
rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address, config.get(CONF_RESOLUTION))
rhs = hub.Pget_sensor_by_address(address, config.get(CONF_RESOLUTION))
else:
rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
config.get(CONF_RESOLUTION))
rhs = hub.Pget_sensor_by_index(config[CONF_INDEX], config.get(CONF_RESOLUTION))
var = cg.Pvariable(config[CONF_ID], rhs)
yield sensor.register_sensor(var, config)

5
esphome/components/debug/__init__.py
View File

@ -7,11 +7,10 @@ DEPENDENCIES = ['logger']
debug_ns = cg.esphome_ns.namespace('debug')
DebugComponent = debug_ns.class_('DebugComponent', cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DebugComponent),
cv.GenerateID(): cv.declare_id(DebugComponent),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
rhs = DebugComponent.new()
var = cg.Pvariable(config[CONF_ID], rhs)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)

38
esphome/components/deep_sleep/__init__.py
View File

@ -1,7 +1,7 @@
from esphome import pins
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.automation import ACTION_REGISTRY, maybe_simple_id
import esphome.config_validation as cv
from esphome import pins, automation
from esphome.automation import maybe_simple_id
from esphome.const import CONF_ID, CONF_MODE, CONF_NUMBER, CONF_PINS, CONF_RUN_CYCLES, \
CONF_RUN_DURATION, CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
@ -16,8 +16,8 @@ def validate_pin_number(value):
deep_sleep_ns = cg.esphome_ns.namespace('deep_sleep')
DeepSleepComponent = deep_sleep_ns.class_('DeepSleepComponent', cg.Component)
EnterDeepSleepAction = deep_sleep_ns.class_('EnterDeepSleepAction', cg.Action)
PreventDeepSleepAction = deep_sleep_ns.class_('PreventDeepSleepAction', cg.Action)
EnterDeepSleepAction = deep_sleep_ns.class_('EnterDeepSleepAction', automation.Action)
PreventDeepSleepAction = deep_sleep_ns.class_('PreventDeepSleepAction', automation.Action)
WakeupPinMode = deep_sleep_ns.enum('WakeupPinMode')
WAKEUP_PIN_MODES = {
@ -37,17 +37,17 @@ CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
CONF_ESP32_EXT1_WAKEUP = 'esp32_ext1_wakeup'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DeepSleepComponent),
cv.GenerateID(): cv.declare_id(DeepSleepComponent),
cv.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
cv.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
cv.Optional(CONF_WAKEUP_PIN): cv.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema,
validate_pin_number),
cv.Optional(CONF_WAKEUP_PIN_MODE): cv.All(cv.only_on_esp32,
cv.one_of(*WAKEUP_PIN_MODES), upper=True),
cv.enum(WAKEUP_PIN_MODES), upper=True),
cv.Optional(CONF_ESP32_EXT1_WAKEUP): cv.All(cv.only_on_esp32, cv.Schema({
cv.Required(CONF_PINS): cv.ensure_list(pins.shorthand_input_pin, validate_pin_number),
cv.Required(CONF_MODE): cv.one_of(*EXT1_WAKEUP_MODES, upper=True),
cv.Required(CONF_MODE): cv.enum(EXT1_WAKEUP_MODES, upper=True),
})),
cv.Optional(CONF_RUN_CYCLES): cv.invalid("The run_cycles option has been removed in 1.11.0 as "
@ -66,7 +66,7 @@ def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_WAKEUP_PIN])
cg.add(var.set_wakeup_pin(pin))
if CONF_WAKEUP_PIN_MODE in config:
cg.add(var.set_wakeup_pin_mode(WAKEUP_PIN_MODES[config[CONF_WAKEUP_PIN_MODE]]))
cg.add(var.set_wakeup_pin_mode(config[CONF_WAKEUP_PIN_MODE]))
if CONF_RUN_DURATION in config:
cg.add(var.set_run_duration(config[CONF_RUN_DURATION]))
@ -78,7 +78,7 @@ def to_code(config):
struct = cg.StructInitializer(
Ext1Wakeup,
('mask', mask),
('wakeup_mode', EXT1_WAKEUP_MODES[conf[CONF_MODE]])
('wakeup_mode', conf[CONF_MODE])
)
cg.add(var.set_ext1_wakeup(struct))
@ -86,21 +86,17 @@ def to_code(config):
DEEP_SLEEP_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(DeepSleepComponent),
cv.GenerateID(): cv.use_id(DeepSleepComponent),
})
@ACTION_REGISTRY.register('deep_sleep.enter', DEEP_SLEEP_ACTION_SCHEMA)
@automation.register_action('deep_sleep.enter', EnterDeepSleepAction, DEEP_SLEEP_ACTION_SCHEMA)
def deep_sleep_enter_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = EnterDeepSleepAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@ACTION_REGISTRY.register('deep_sleep.prevent', DEEP_SLEEP_ACTION_SCHEMA)
@automation.register_action('deep_sleep.prevent', PreventDeepSleepAction, DEEP_SLEEP_ACTION_SCHEMA)
def deep_sleep_prevent_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = PreventDeepSleepAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)

10
esphome/components/deep_sleep/deep_sleep_component.h
View File

@ -85,10 +85,7 @@ template<typename... Ts> class EnterDeepSleepAction : public Action<Ts...> {
public:
EnterDeepSleepAction(DeepSleepComponent *deep_sleep) : deep_sleep_(deep_sleep) {}
void play(Ts... x) override {
this->deep_sleep_->begin_sleep(true);
this->play_next(x...);
}
void play(Ts... x) override { this->deep_sleep_->begin_sleep(true); }
protected:
DeepSleepComponent *deep_sleep_;
@ -98,10 +95,7 @@ template<typename... Ts> class PreventDeepSleepAction : public Action<Ts...> {
public:
PreventDeepSleepAction(DeepSleepComponent *deep_sleep) : deep_sleep_(deep_sleep) {}
void play(Ts... x) override {
this->deep_sleep_->prevent_deep_sleep();
this->play_next(x...);
}
void play(Ts... x) override { this->deep_sleep_->prevent_deep_sleep(); }
protected:
DeepSleepComponent *deep_sleep_;

8
esphome/components/dht/dht.cpp
View File

@ -7,12 +7,6 @@ namespace dht {
static const char *TAG = "dht";
DHT::DHT(const std::string &temperature_name, const std::string &humidity_name, GPIOPin *pin, uint32_t update_interval)
: PollingComponent(update_interval),
pin_(pin),
temperature_sensor_(new sensor::Sensor(temperature_name)),
humidity_sensor_(new sensor::Sensor(humidity_name)) {}
void DHT::setup() {
ESP_LOGCONFIG(TAG, "Setting up DHT...");
this->pin_->digital_write(true);
@ -71,8 +65,6 @@ void DHT::set_dht_model(DHTModel model) {
this->model_ = model;
this->is_auto_detect_ = model == DHT_MODEL_AUTO_DETECT;
}
sensor::Sensor *DHT::get_temperature_sensor() const { return this->temperature_sensor_; }
sensor::Sensor *DHT::get_humidity_sensor() const { return this->humidity_sensor_; }
bool HOT DHT::read_sensor_(float *temperature, float *humidity, bool report_errors) {
*humidity = NAN;
*temperature = NAN;

19
esphome/components/dht/dht.h
View File

@ -18,13 +18,6 @@ enum DHTModel {
/// Component for reading temperature/humidity measurements from DHT11/DHT22 sensors.
class DHT : public PollingComponent {
public:
/** Construct a DHTComponent.
*
* @param pin The pin which DHT sensor is connected to.
* @param update_interval The interval in ms the sensor should be checked.
*/
DHT(const std::string &temperature_name, const std::string &humidity_name, GPIOPin *pin, uint32_t update_interval);
/** Manually select the DHT model.
*
* Valid values are:
@ -40,10 +33,10 @@ class DHT : public PollingComponent {
*/
void set_dht_model(DHTModel model);
// ========== INTERNAL METHODS ==========
// (In most use cases you won't need these)
sensor::Sensor *get_temperature_sensor() const;
sensor::Sensor *get_humidity_sensor() const;
void set_pin(GPIOPin *pin) { pin_ = pin; }
void set_model(DHTModel model) { model_ = model; }
void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
/// Set up the pins and check connection.
void setup() override;
@ -59,8 +52,8 @@ class DHT : public PollingComponent {
GPIOPin *pin_;
DHTModel model_{DHT_MODEL_AUTO_DETECT};
bool is_auto_detect_{false};
sensor::Sensor *temperature_sensor_;
sensor::Sensor *humidity_sensor_;
sensor::Sensor *temperature_sensor_{nullptr};
sensor::Sensor *humidity_sensor_{nullptr};
};
} // namespace dht

53
esphome/components/dht/sensor.py
View File

@ -1,11 +1,10 @@
from esphome.components import sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, \
CONF_PIN, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, CONF_ACCURACY_DECIMALS, CONF_ICON, \
ICON_THERMOMETER, CONF_UNIT_OF_MEASUREMENT, UNIT_CELSIUS, ICON_WATER_PERCENT, UNIT_PERCENT
import esphome.config_validation as cv
from esphome import pins
from esphome.components import sensor
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_PIN, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, ICON_THERMOMETER, UNIT_CELSIUS, ICON_WATER_PERCENT, UNIT_PERCENT
from esphome.cpp_helpers import gpio_pin_expression
from esphome.pins import gpio_input_pullup_pin_schema
dht_ns = cg.esphome_ns.namespace('dht')
DHTModel = dht_ns.enum('DHTModel')
@ -20,31 +19,27 @@ DHT_MODELS = {
DHT = dht_ns.class_('DHT', cg.PollingComponent)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DHT),
cv.Required(CONF_PIN): gpio_input_pullup_pin_schema,
cv.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.Optional(CONF_ACCURACY_DECIMALS, default=1): sensor.accuracy_decimals,
cv.Optional(CONF_ICON, default=ICON_THERMOMETER): sensor.icon,
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_CELSIUS): sensor.unit_of_measurement,
})),
cv.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.Optional(CONF_ACCURACY_DECIMALS, default=0): sensor.accuracy_decimals,
cv.Optional(CONF_ICON, default=ICON_WATER_PERCENT): sensor.icon,
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_PERCENT): sensor.unit_of_measurement,
})),
cv.Optional(CONF_MODEL, default='auto detect'): cv.one_of(*DHT_MODELS, upper=True, space='_'),
cv.GenerateID(): cv.declare_id(DHT),
cv.Required(CONF_PIN): pins.gpio_input_pin_schema,
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0),
cv.Optional(CONF_MODEL, default='auto detect'): cv.enum(DHT_MODELS, upper=True, space='_'),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA)
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
pin = yield gpio_pin_expression(config[CONF_PIN])
rhs = DHT.new(config[CONF_TEMPERATURE][CONF_NAME],
config[CONF_HUMIDITY][CONF_NAME],
pin, config[CONF_UPDATE_INTERVAL])
dht = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(dht, config)
yield sensor.register_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
yield sensor.register_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(dht.set_dht_model(DHT_MODELS[config[CONF_MODEL]]))
pin = yield gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
if CONF_TEMPERATURE in config:
sens = yield sensor.new_sensor(config[CONF_TEMPERATURE])
cg.add(var.set_temperature_sensor(sens))
if CONF_HUMIDITY in config:
sens = yield sensor.new_sensor(config[CONF_HUMIDITY])
cg.add(var.set_humidity_sensor(sens))
cg.add(var.set_dht_model(config[CONF_MODEL]))

2
esphome/components/dht12/dht12.h
View File

@ -9,8 +9,6 @@ namespace dht12 {
class DHT12Component : public PollingComponent, public i2c::I2CDevice {
public:
DHT12Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

15
esphome/components/dht12/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
DEPENDENCIES = ['i2c']
@ -10,17 +10,14 @@ dht12_ns = cg.esphome_ns.namespace('dht12')
DHT12Component = dht12_ns.class_('DHT12Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(DHT12Component),
cv.Optional(CONF_TEMPERATURE):
cv.nameable(sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1)),
cv.Optional(CONF_HUMIDITY):
cv.nameable(sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x5C))
cv.GenerateID(): cv.declare_id(DHT12Component),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x5C))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

54
esphome/components/display/__init__.py
View File

@ -1,8 +1,8 @@
# coding=utf-8
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import core
from esphome.automation import ACTION_REGISTRY, maybe_simple_id
from esphome import core, automation
from esphome.automation import maybe_simple_id
from esphome.const import CONF_ID, CONF_LAMBDA, CONF_PAGES, CONF_ROTATION, CONF_UPDATE_INTERVAL
from esphome.core import coroutine
@ -13,9 +13,9 @@ DisplayBuffer = display_ns.class_('DisplayBuffer')
DisplayPage = display_ns.class_('DisplayPage')
DisplayPagePtr = DisplayPage.operator('ptr')
DisplayBufferRef = DisplayBuffer.operator('ref')
DisplayPageShowAction = display_ns.class_('DisplayPageShowAction', cg.Action)
DisplayPageShowNextAction = display_ns.class_('DisplayPageShowNextAction', cg.Action)
DisplayPageShowPrevAction = display_ns.class_('DisplayPageShowPrevAction', cg.Action)
DisplayPageShowAction = display_ns.class_('DisplayPageShowAction', automation.Action)
DisplayPageShowNextAction = display_ns.class_('DisplayPageShowNextAction', automation.Action)
DisplayPageShowPrevAction = display_ns.class_('DisplayPageShowPrevAction', automation.Action)
DISPLAY_ROTATIONS = {
0: display_ns.DISPLAY_ROTATION_0_DEGREES,
@ -29,11 +29,7 @@ def validate_rotation(value):
value = cv.string(value)
if value.endswith(u"°"):
value = value[:-1]
try:
value = int(value)
except ValueError:
raise cv.Invalid(u"Expected integer for rotation")
return cv.one_of(*DISPLAY_ROTATIONS)(value)
return cv.enum(DISPLAY_ROTATIONS, int=True)(value)
BASIC_DISPLAY_SCHEMA = cv.Schema({
@ -44,7 +40,7 @@ BASIC_DISPLAY_SCHEMA = cv.Schema({
FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend({
cv.Optional(CONF_ROTATION): validate_rotation,
cv.Optional(CONF_PAGES): cv.All(cv.ensure_list({
cv.GenerateID(): cv.declare_variable_id(DisplayPage),
cv.GenerateID(): cv.declare_id(DisplayPage),
cv.Required(CONF_LAMBDA): cv.lambda_,
}), cv.Length(min=1)),
})
@ -71,37 +67,35 @@ def register_display(var, config):
yield setup_display_core_(var, config)
@ACTION_REGISTRY.register('display.page.show', maybe_simple_id({
cv.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayPage)),
@automation.register_action('display.page.show', DisplayPageShowAction, maybe_simple_id({
cv.Required(CONF_ID): cv.templatable(cv.use_id(DisplayPage)),
}))
def display_page_show_to_code(config, action_id, template_arg, args):
type = DisplayPageShowAction.template(template_arg)
action = cg.Pvariable(action_id, type.new(), type=type)
var = cg.new_Pvariable(action_id, template_arg)
if isinstance(config[CONF_ID], core.Lambda):
template_ = yield cg.templatable(config[CONF_ID], args, DisplayPagePtr)
cg.add(action.set_page(template_))
cg.add(var.set_page(template_))
else:
var = yield cg.get_variable(config[CONF_ID])
cg.add(action.set_page(var))
yield action
paren = yield cg.get_variable(config[CONF_ID])
cg.add(var.set_page(paren))
yield var
@ACTION_REGISTRY.register('display.page.show_next', maybe_simple_id({
cv.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayBuffer)),
@automation.register_action('display.page.show_next', DisplayPageShowNextAction, maybe_simple_id({
cv.Required(CONF_ID): cv.templatable(cv.use_id(DisplayBuffer)),
}))
def display_page_show_next_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = DisplayPageShowNextAction.template(template_arg)
yield cg.Pvariable(action_id, type.new(var), type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@ACTION_REGISTRY.register('display.page.show_previous', maybe_simple_id({
cv.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayBuffer)),
}))
@automation.register_action('display.page.show_previous', DisplayPageShowPrevAction,
maybe_simple_id({
cv.Required(CONF_ID): cv.templatable(cv.use_id(DisplayBuffer)),
}))
def display_page_show_previous_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = DisplayPageShowPrevAction.template(template_arg)
yield cg.Pvariable(action_id, type.new(var), type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
def to_code(config):

11
esphome/components/display/display_buffer.h
View File

@ -396,17 +396,13 @@ template<typename... Ts> class DisplayPageShowAction : public Action<Ts...> {
if (page != nullptr) {
page->show();
}
this->play_next(x...);
}
};
template<typename... Ts> class DisplayPageShowNextAction : public Action<Ts...> {
public:
DisplayPageShowNextAction(DisplayBuffer *buffer) : buffer_(buffer) {}
void play(Ts... x) override {
this->buffer_->show_next_page();
this->play_next(x...);
}
void play(Ts... x) override { this->buffer_->show_next_page(); }
protected:
DisplayBuffer *buffer_;
@ -415,10 +411,7 @@ template<typename... Ts> class DisplayPageShowNextAction : public Action<Ts...>
template<typename... Ts> class DisplayPageShowPrevAction : public Action<Ts...> {
public:
DisplayPageShowPrevAction(DisplayBuffer *buffer) : buffer_(buffer) {}
void play(Ts... x) override {
this->buffer_->show_prev_page();
this->play_next(x...);
}
void play(Ts... x) override { this->buffer_->show_prev_page(); }
protected:
DisplayBuffer *buffer_;

5
esphome/components/duty_cycle/duty_cycle_sensor.h
View File

@ -17,10 +17,9 @@ struct DutyCycleSensorStore {
static void gpio_intr(DutyCycleSensorStore *arg);
};
class DutyCycleSensor : public sensor::PollingSensorComponent {
class DutyCycleSensor : public sensor::Sensor, public PollingComponent {
public:
DutyCycleSensor(const std::string &name, uint32_t update_interval, GPIOPin *pin)
: PollingSensorComponent(name, update_interval), pin_(pin) {}
void set_pin(GPIOPin *pin) { pin_ = pin; }
void setup() override;
float get_setup_priority() const override;

20
esphome/components/duty_cycle/sensor.py
View File

@ -1,23 +1,23 @@
import esphome.codegen as cg
import esphome.config_validation as cv
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_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL, UNIT_PERCENT, \
ICON_PERCENT
from esphome.const import CONF_ID, CONF_PIN, UNIT_PERCENT, ICON_PERCENT
duty_cycle_ns = cg.esphome_ns.namespace('duty_cycle')
DutyCycleSensor = duty_cycle_ns.class_('DutyCycleSensor', sensor.PollingSensorComponent)
CONFIG_SCHEMA = cv.nameable(sensor.sensor_schema(UNIT_PERCENT, ICON_PERCENT, 1).extend({
cv.GenerateID(): cv.declare_variable_id(DutyCycleSensor),
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_PERCENT, ICON_PERCENT, 1).extend({
cv.GenerateID(): cv.declare_id(DutyCycleSensor),
cv.Required(CONF_PIN): cv.All(pins.internal_gpio_input_pin_schema,
pins.validate_has_interrupt),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA))
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_UPDATE_INTERVAL], pin)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))

18
esphome/components/endstop/cover.py
View File

@ -1,32 +1,32 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.components import binary_sensor, cover
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_CLOSE_ACTION, CONF_CLOSE_DURATION, \
CONF_CLOSE_ENDSTOP, CONF_ID, CONF_NAME, CONF_OPEN_ACTION, CONF_OPEN_DURATION, \
CONF_CLOSE_ENDSTOP, CONF_ID, CONF_OPEN_ACTION, CONF_OPEN_DURATION, \
CONF_OPEN_ENDSTOP, CONF_STOP_ACTION, CONF_MAX_DURATION
endstop_ns = cg.esphome_ns.namespace('endstop')
EndstopCover = endstop_ns.class_('EndstopCover', cover.Cover, cg.Component)
CONFIG_SCHEMA = cv.nameable(cover.COVER_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(EndstopCover),
CONFIG_SCHEMA = cover.COVER_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(EndstopCover),
cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
cv.Required(CONF_OPEN_ENDSTOP): cv.use_variable_id(binary_sensor.BinarySensor),
cv.Required(CONF_OPEN_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
cv.Required(CONF_CLOSE_ENDSTOP): cv.use_variable_id(binary_sensor.BinarySensor),
cv.Required(CONF_CLOSE_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
cv.Optional(CONF_MAX_DURATION): cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA))
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield cover.register_cover(var, config)

2
esphome/components/endstop/endstop_cover.h
View File

@ -10,8 +10,6 @@ namespace endstop {
class EndstopCover : public cover::Cover, public Component {
public:
EndstopCover(const std::string &name) : cover::Cover(name) {}
void setup() override;
void loop() override;
void dump_config() override;

2
esphome/components/esp32_ble_beacon/__init__.py
View File

@ -12,7 +12,7 @@ CONF_MAJOR = 'major'
CONF_MINOR = 'minor'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(ESP32BLEBeacon),
cv.GenerateID(): cv.declare_id(ESP32BLEBeacon),
cv.Required(CONF_TYPE): cv.one_of('IBEACON', upper=True),
cv.Required(CONF_UUID): cv.uuid,
cv.Optional(CONF_MAJOR, default=10167): cv.uint16_t,

4
esphome/components/esp32_ble_tracker/__init__.py
View File

@ -11,12 +11,12 @@ ESP32BLETracker = esp32_ble_tracker_ns.class_('ESP32BLETracker', cg.Component)
ESPBTDeviceListener = esp32_ble_tracker_ns.class_('ESPBTDeviceListener')
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(ESP32BLETracker),
cv.GenerateID(): cv.declare_id(ESP32BLETracker),
cv.Optional(CONF_SCAN_INTERVAL, default='300s'): cv.positive_time_period_seconds,
}).extend(cv.COMPONENT_SCHEMA)
ESP_BLE_DEVICE_SCHEMA = cv.Schema({
cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker),
cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_id(ESP32BLETracker),
})

6
esphome/components/esp32_camera/__init__.py
View File

@ -58,7 +58,7 @@ CONF_TEST_PATTERN = 'test_pattern'
camera_range_param = cv.All(cv.int_, cv.Range(min=-2, max=2))
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(ESP32Camera),
cv.GenerateID(): cv.declare_id(ESP32Camera),
cv.Required(CONF_NAME): cv.string,
cv.Required(CONF_DATA_PINS): cv.All([pins.input_pin], cv.Length(min=8, max=8)),
cv.Required(CONF_VSYNC_PIN): pins.input_pin,
@ -80,7 +80,7 @@ CONFIG_SCHEMA = cv.Schema({
max=60)),
cv.Optional(CONF_IDLE_FRAMERATE, default='0.1 fps'): cv.All(cv.framerate,
cv.Range(min=0, max=1)),
cv.Optional(CONF_RESOLUTION, default='640X480'): cv.one_of(*FRAME_SIZES, upper=True),
cv.Optional(CONF_RESOLUTION, default='640X480'): cv.enum(FRAME_SIZES, upper=True),
cv.Optional(CONF_JPEG_QUALITY, default=10): cv.All(cv.int_, cv.Range(min=10, max=63)),
cv.Optional(CONF_CONTRAST, default=0): camera_range_param,
cv.Optional(CONF_BRIGHTNESS, default=0): camera_range_param,
@ -124,7 +124,7 @@ def to_code(config):
cg.add(var.set_idle_update_interval(0))
else:
cg.add(var.set_idle_update_interval(1000 / config[CONF_IDLE_FRAMERATE]))
cg.add(var.set_frame_size(FRAME_SIZES[config[CONF_RESOLUTION]]))
cg.add(var.set_frame_size(config[CONF_RESOLUTION]))
cg.add_define('USE_ESP32_CAMERA')
cg.add_build_flag('-DBOARD_HAS_PSRAM')

16
esphome/components/esp32_hall/sensor.py
View File

@ -1,22 +1,18 @@
from esphome.components import sensor
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32, \
CONF_UNIT_OF_MEASUREMENT, CONF_ICON, CONF_ACCURACY_DECIMALS, UNIT_MICROTESLA, ICON_MAGNET
UNIT_MICROTESLA, ICON_MAGNET
ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
esp32_hall_ns = cg.esphome_ns.namespace('esp32_hall')
ESP32HallSensor = esp32_hall_ns.class_('ESP32HallSensor', sensor.PollingSensorComponent)
CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(ESP32HallSensor),
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_MICROTESLA, ICON_MAGNET, 1).extend({
cv.GenerateID(): cv.declare_id(ESP32HallSensor),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_MICROTESLA): sensor.unit_of_measurement,
cv.Optional(CONF_ICON, default=ICON_MAGNET): sensor.icon,
cv.Optional(CONF_ACCURACY_DECIMALS, default=-1): sensor.accuracy_decimals,
}).extend(cv.COMPONENT_SCHEMA))
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):

2
esphome/components/esp32_touch/__init__.py
View File

@ -44,7 +44,7 @@ VOLTAGE_ATTENUATION = {
}
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(ESP32TouchComponent),
cv.GenerateID(): cv.declare_id(ESP32TouchComponent),
cv.Optional(CONF_SETUP_MODE, default=False): cv.boolean,
cv.Optional(CONF_IIR_FILTER, default='0ms'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_SLEEP_DURATION, default='27306us'):

8
esphome/components/esp32_touch/binary_sensor.py
View File

@ -34,12 +34,12 @@ def validate_touch_pad(value):
ESP32TouchBinarySensor = esp32_touch_ns.class_('ESP32TouchBinarySensor', binary_sensor.BinarySensor)
CONFIG_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(ESP32TouchBinarySensor),
cv.GenerateID(CONF_ESP32_TOUCH_ID): cv.use_variable_id(ESP32TouchComponent),
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(ESP32TouchBinarySensor),
cv.GenerateID(CONF_ESP32_TOUCH_ID): cv.use_id(ESP32TouchComponent),
cv.Required(CONF_PIN): validate_touch_pad,
cv.Required(CONF_THRESHOLD): cv.uint16_t,
}))
})
def to_code(config):

2
esphome/components/esp8266_pwm/esp8266_pwm.cpp
View File

@ -25,6 +25,8 @@ void ESP8266PWM::dump_config() {
LOG_FLOAT_OUTPUT(this);
}
void HOT ESP8266PWM::write_state(float state) {
this->last_output_ = state;
// Also check pin inversion
if (this->pin_->is_inverted()) {
state = 1.0f - state;

25
esphome/components/esp8266_pwm/esp8266_pwm.h
View File

@ -2,6 +2,7 @@
#include "esphome/core/component.h"
#include "esphome/core/esphal.h"
#include "esphome/core/automation.h"
#include "esphome/components/output/float_output.h"
namespace esphome {
@ -9,9 +10,13 @@ namespace esp8266_pwm {
class ESP8266PWM : public output::FloatOutput, public Component {
public:
explicit ESP8266PWM(GPIOPin *pin) : pin_(pin) {}
void set_pin(GPIOPin *pin) { pin_ = pin; }
void set_frequency(float frequency) { this->frequency_ = frequency; }
/// Dynamically update frequency
void update_frequency(float frequency) {
this->set_frequency(frequency);
this->write_state(this->last_output_);
}
/// Initialize pin
void setup() override;
@ -24,6 +29,22 @@ class ESP8266PWM : public output::FloatOutput, public Component {
GPIOPin *pin_;
float frequency_{1000.0};
/// Cache last output level for dynamic frequency updating
float last_output_{0.0};
};
template<typename... Ts> class SetFrequencyAction : public Action<Ts...> {
public:
SetFrequencyAction(ESP8266PWM *parent) : parent_(parent) {}
TEMPLATABLE_VALUE(float, frequency);
void play(Ts... x) {
float freq = this->frequency_.value(x...);
this->parent_->update_frequency(freq);
}
protected:
ESP8266PWM *parent_;
};
} // namespace esp8266_pwm

26
esphome/components/esp8266_pwm/output.py
View File

@ -1,4 +1,4 @@
from esphome import pins
from esphome import pins, automation
from esphome.components import output
import esphome.config_validation as cv
import esphome.codegen as cg
@ -15,18 +15,34 @@ def valid_pwm_pin(value):
esp8266_pwm_ns = cg.esphome_ns.namespace('esp8266_pwm')
ESP8266PWM = esp8266_pwm_ns.class_('ESP8266PWM', output.FloatOutput, cg.Component)
SetFrequencyAction = esp8266_pwm_ns.class_('SetFrequencyAction', automation.Action)
validate_frequency = cv.All(cv.frequency, cv.Range(min=1.0e-6))
CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
cv.Required(CONF_ID): cv.declare_variable_id(ESP8266PWM),
cv.Required(CONF_ID): cv.declare_id(ESP8266PWM),
cv.Required(CONF_PIN): cv.All(pins.internal_gpio_output_pin_schema, valid_pwm_pin),
cv.Optional(CONF_FREQUENCY, default='1kHz'): cv.All(cv.frequency, cv.Range(min=1.0e-6)),
cv.Optional(CONF_FREQUENCY, default='1kHz'): validate_frequency,
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
var = cg.new_Pvariable(config[CONF_ID], pin)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield output.register_output(var, config)
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
cg.add(var.set_frequency(config[CONF_FREQUENCY]))
@automation.register_action('output.esp8266_pwm.set_frequency', SetFrequencyAction, cv.Schema({
cv.Required(CONF_ID): cv.use_id(ESP8266PWM),
cv.Required(CONF_FREQUENCY): cv.templatable(validate_frequency),
}))
def esp8266_set_frequency_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
template_ = yield cg.templatable(config[CONF_FREQUENCY], args, float)
cg.add(var.set_frequency(template_))
yield var

11
esphome/components/ethernet/__init__.py
View File

@ -7,6 +7,7 @@ from esphome.core import CORE, coroutine_with_priority
CONFLICTS_WITH = ['wifi']
ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
AUTO_LOAD = ['network']
ethernet_ns = cg.esphome_ns.namespace('ethernet')
CONF_PHY_ADDR = 'phy_addr'
@ -54,12 +55,12 @@ def validate(config):
CONFIG_SCHEMA = cv.All(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(EthernetComponent),
cv.Required(CONF_TYPE): cv.one_of(*ETHERNET_TYPES, upper=True),
cv.GenerateID(): cv.declare_id(EthernetComponent),
cv.Required(CONF_TYPE): cv.enum(ETHERNET_TYPES, upper=True),
cv.Required(CONF_MDC_PIN): pins.output_pin,
cv.Required(CONF_MDIO_PIN): pins.input_output_pin,
cv.Optional(CONF_CLK_MODE, default='GPIO0_IN'): cv.one_of(*CLK_MODES, upper=True, space='_'),
cv.Optional(CONF_PHY_ADDR, default=0): cv.All(cv.int_, cv.Range(min=0, max=31)),
cv.Optional(CONF_CLK_MODE, default='GPIO0_IN'): cv.enum(CLK_MODES, upper=True, space='_'),
cv.Optional(CONF_PHY_ADDR, default=0): cv.int_range(min=0, max=31),
cv.Optional(CONF_POWER_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_MANUAL_IP): MANUAL_IP_SCHEMA,
cv.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
@ -87,7 +88,7 @@ def to_code(config):
cg.add(var.set_phy_addr(config[CONF_PHY_ADDR]))
cg.add(var.set_mdc_pin(config[CONF_MDC_PIN]))
cg.add(var.set_mdio_pin(config[CONF_MDIO_PIN]))
cg.add(var.set_type(ETHERNET_TYPES[config[CONF_TYPE]]))
cg.add(var.set_type(config[CONF_TYPE]))
cg.add(var.set_clk_mode(CLK_MODES[config[CONF_CLK_MODE]]))
cg.add(var.set_use_address(config[CONF_USE_ADDRESS]))

57
esphome/components/fan/__init__.py
View File

@ -1,6 +1,7 @@
from esphome.automation import ACTION_REGISTRY, maybe_simple_id
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.automation import maybe_simple_id
from esphome.components import mqtt
from esphome.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_OSCILLATING, \
CONF_OSCILLATION_COMMAND_TOPIC, CONF_OSCILLATION_STATE_TOPIC, CONF_SPEED, \
@ -14,9 +15,9 @@ FanState = fan_ns.class_('FanState', cg.Nameable, cg.Component)
MakeFan = cg.Application.struct('MakeFan')
# Actions
TurnOnAction = fan_ns.class_('TurnOnAction', cg.Action)
TurnOffAction = fan_ns.class_('TurnOffAction', cg.Action)
ToggleAction = fan_ns.class_('ToggleAction', cg.Action)
TurnOnAction = fan_ns.class_('TurnOnAction', automation.Action)
TurnOffAction = fan_ns.class_('TurnOffAction', automation.Action)
ToggleAction = fan_ns.class_('ToggleAction', automation.Action)
FanSpeed = fan_ns.enum('FanSpeed')
FAN_SPEEDS = {
@ -27,8 +28,8 @@ FAN_SPEEDS = {
}
FAN_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(FanState),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_variable_id(mqtt.MQTTFanComponent),
cv.GenerateID(): cv.declare_id(FanState),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTFanComponent),
cv.Optional(CONF_OSCILLATION_STATE_TOPIC): cv.All(cv.requires_component('mqtt'),
cv.publish_topic),
cv.Optional(CONF_OSCILLATION_COMMAND_TOPIC): cv.All(cv.requires_component('mqtt'),
@ -38,6 +39,7 @@ FAN_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
@coroutine
def setup_fan_core_(var, config):
cg.add(var.set_name(config[CONF_NAME]))
if CONF_INTERNAL in config:
cg.add(var.set_internal(config[CONF_INTERNAL]))
@ -66,50 +68,43 @@ def register_fan(var, config):
@coroutine
def create_fan_state(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
var = cg.new_Pvariable(config[CONF_ID])
yield register_fan(var, config)
yield var
FAN_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(FanState),
cv.Required(CONF_ID): cv.use_id(FanState),
})
@ACTION_REGISTRY.register('fan.toggle', FAN_ACTION_SCHEMA)
@automation.register_action('fan.toggle', ToggleAction, FAN_ACTION_SCHEMA)
def fan_toggle_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = ToggleAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@ACTION_REGISTRY.register('fan.turn_off', FAN_ACTION_SCHEMA)
@automation.register_action('fan.turn_off', TurnOffAction, FAN_ACTION_SCHEMA)
def fan_turn_off_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = TurnOffAction.template(template_arg)
rhs = type.new(var)
yield cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@ACTION_REGISTRY.register('fan.turn_on', maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(FanState),
@automation.register_action('fan.turn_on', TurnOnAction, maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(FanState),
cv.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean),
cv.Optional(CONF_SPEED): cv.templatable(cv.one_of(*FAN_SPEEDS, upper=True)),
cv.Optional(CONF_SPEED): cv.templatable(cv.enum(FAN_SPEEDS, upper=True)),
}))
def fan_turn_on_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = TurnOnAction.template(template_arg)
rhs = type.new(var)
action = cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_OSCILLATING in config:
template_ = yield cg.templatable(config[CONF_OSCILLATING], args, bool)
cg.add(action.set_oscillating(template_))
cg.add(var.set_oscillating(template_))
if CONF_SPEED in config:
template_ = yield cg.templatable(config[CONF_SPEED], args, FanSpeed,
to_exp=FAN_SPEEDS)
cg.add(action.set_speed(template_))
yield action
template_ = yield cg.templatable(config[CONF_SPEED], args, FanSpeed)
cg.add(var.set_speed(template_))
yield var
def to_code(config):

11
esphome/components/fan/automation.h
View File

@ -23,7 +23,6 @@ template<typename... Ts> class TurnOnAction : public Action<Ts...> {
call.set_speed(this->speed_.value(x...));
}
call.perform();
this->play_next(x...);
}
protected:
@ -34,10 +33,7 @@ template<typename... Ts> class TurnOffAction : public Action<Ts...> {
public:
explicit TurnOffAction(FanState *state) : state_(state) {}
void play(Ts... x) override {
this->state_->turn_off().perform();
this->play_next(x...);
}
void play(Ts... x) override { this->state_->turn_off().perform(); }
protected:
FanState *state_;
@ -47,10 +43,7 @@ template<typename... Ts> class ToggleAction : public Action<Ts...> {
public:
explicit ToggleAction(FanState *state) : state_(state) {}
void play(Ts... x) override {
this->state_->toggle().perform();
this->play_next(x...);
}
void play(Ts... x) override { this->state_->toggle().perform(); }
protected:
FanState *state_;

37
esphome/components/fan/fan_state.cpp
View File

@ -13,10 +13,10 @@ void FanState::add_on_state_callback(std::function<void()> &&callback) {
}
FanState::FanState(const std::string &name) : Nameable(name) {}
FanState::StateCall FanState::turn_on() { return this->make_call().set_state(true); }
FanState::StateCall FanState::turn_off() { return this->make_call().set_state(false); }
FanState::StateCall FanState::toggle() { return this->make_call().set_state(!this->state); }
FanState::StateCall FanState::make_call() { return FanState::StateCall(this); }
FanStateCall FanState::turn_on() { return this->make_call().set_state(true); }
FanStateCall FanState::turn_off() { return this->make_call().set_state(false); }
FanStateCall FanState::toggle() { return this->make_call().set_state(!this->state); }
FanStateCall FanState::make_call() { return FanStateCall(this); }
struct FanStateRTCState {
bool state;
@ -39,32 +39,7 @@ void FanState::setup() {
float FanState::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
uint32_t FanState::hash_base() { return 418001110UL; }
FanState::StateCall::StateCall(FanState *state) : state_(state) {}
FanState::StateCall &FanState::StateCall::set_state(bool state) {
this->binary_state_ = state;
return *this;
}
FanState::StateCall &FanState::StateCall::set_state(optional<bool> state) {
this->binary_state_ = state;
return *this;
}
FanState::StateCall &FanState::StateCall::set_oscillating(bool oscillating) {
this->oscillating_ = oscillating;
return *this;
}
FanState::StateCall &FanState::StateCall::set_oscillating(optional<bool> oscillating) {
this->oscillating_ = oscillating;
return *this;
}
FanState::StateCall &FanState::StateCall::set_speed(FanSpeed speed) {
this->speed_ = speed;
return *this;
}
FanState::StateCall &FanState::StateCall::set_speed(optional<FanSpeed> speed) {
this->speed_ = speed;
return *this;
}
void FanState::StateCall::perform() const {
void FanStateCall::perform() const {
if (this->binary_state_.has_value()) {
this->state_->state = *this->binary_state_;
}
@ -92,7 +67,7 @@ void FanState::StateCall::perform() const {
this->state_->state_callback_.call();
}
FanState::StateCall &FanState::StateCall::set_speed(const char *speed) {
FanStateCall &FanStateCall::set_speed(const char *speed) {
if (strcasecmp(speed, "low") == 0) {
this->set_speed(FAN_SPEED_LOW);
} else if (strcasecmp(speed, "medium") == 0) {

73
esphome/components/fan/fan_state.h
View File

@ -15,8 +15,50 @@ enum FanSpeed {
FAN_SPEED_HIGH = 2 ///< The fan is running on high/full speed.
};
class FanState;
class FanStateCall {
public:
explicit FanStateCall(FanState *state) : state_(state) {}
FanStateCall &set_state(bool binary_state) {
this->binary_state_ = binary_state;
return *this;
}
FanStateCall &set_state(optional<bool> binary_state) {
this->binary_state_ = binary_state;
return *this;
}
FanStateCall &set_oscillating(bool oscillating) {
this->oscillating_ = oscillating;
return *this;
}
FanStateCall &set_oscillating(optional<bool> oscillating) {
this->oscillating_ = oscillating;
return *this;
}
FanStateCall &set_speed(FanSpeed speed) {
this->speed_ = speed;
return *this;
}
FanStateCall &set_speed(optional<FanSpeed> speed) {
this->speed_ = speed;
return *this;
}
FanStateCall &set_speed(const char *speed);
void perform() const;
protected:
FanState *const state_;
optional<bool> binary_state_;
optional<bool> oscillating_{};
optional<FanSpeed> speed_{};
};
class FanState : public Nameable, public Component {
public:
FanState() = default;
/// Construct the fan state with name.
explicit FanState(const std::string &name);
@ -35,36 +77,17 @@ class FanState : public Nameable, public Component {
/// The current fan speed.
FanSpeed speed{FAN_SPEED_HIGH};
class StateCall {
public:
explicit StateCall(FanState *state);
FanState::StateCall &set_state(bool state);
FanState::StateCall &set_state(optional<bool> state);
FanState::StateCall &set_oscillating(bool oscillating);
FanState::StateCall &set_oscillating(optional<bool> oscillating);
FanState::StateCall &set_speed(FanSpeed speed);
FanState::StateCall &set_speed(optional<FanSpeed> speed);
FanState::StateCall &set_speed(const char *speed);
void perform() const;
protected:
FanState *const state_;
optional<bool> binary_state_;
optional<bool> oscillating_{};
optional<FanSpeed> speed_{};
};
FanState::StateCall turn_on();
FanState::StateCall turn_off();
FanState::StateCall toggle();
FanState::StateCall make_call();
FanStateCall turn_on();
FanStateCall turn_off();
FanStateCall toggle();
FanStateCall make_call();
void setup() override;
float get_setup_priority() const override;
protected:
friend FanStateCall;
uint32_t hash_base() override;
FanTraits traits_{};

4
esphome/components/fastled_base/__init__.py
View File

@ -19,13 +19,13 @@ RGB_ORDERS = [
]
BASE_SCHEMA = light.ADDRESSABLE_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_variable_id(FastLEDLightOutput),
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(FastLEDLightOutput),
cv.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
cv.Optional(CONF_RGB_ORDER): cv.one_of(*RGB_ORDERS, upper=True),
cv.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
cv.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(power_supply.PowerSupply),
cv.Optional(CONF_POWER_SUPPLY): cv.use_id(power_supply.PowerSupply),
}).extend(cv.COMPONENT_SCHEMA)

2
esphome/components/fastled_clockless/light.py
View File

@ -38,7 +38,7 @@ def validate(value):
return value
CONFIG_SCHEMA = cv.nameable(fastled_base.BASE_SCHEMA.extend({
CONFIG_SCHEMA = cv.All(fastled_base.BASE_SCHEMA.extend({
cv.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
cv.Required(CONF_PIN): pins.output_pin,
}), validate)

4
esphome/components/fastled_spi/light.py
View File

@ -17,11 +17,11 @@ CHIPSETS = [
'DOTSTAR',
]
CONFIG_SCHEMA = cv.nameable(fastled_base.BASE_SCHEMA.extend({
CONFIG_SCHEMA = fastled_base.BASE_SCHEMA.extend({
cv.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
cv.Required(CONF_DATA_PIN): pins.output_pin,
cv.Required(CONF_CLOCK_PIN): pins.output_pin,
}))
})
def to_code(config):

6
esphome/components/font/__init__.py
View File

@ -67,11 +67,11 @@ DEFAULT_GLYPHS = u' !"%()+,-.:0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklm
CONF_RAW_DATA_ID = 'raw_data_id'
FONT_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.declare_variable_id(Font),
cv.Required(CONF_ID): cv.declare_id(Font),
cv.Required(CONF_FILE): validate_truetype_file,
cv.Optional(CONF_GLYPHS, default=DEFAULT_GLYPHS): validate_glyphs,
cv.Optional(CONF_SIZE, default=20): cv.All(cv.int_, cv.Range(min=1)),
cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(cg.uint8),
cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
})
CONFIG_SCHEMA = cv.All(validate_pillow_installed, FONT_SCHEMA)
@ -80,7 +80,7 @@ CONFIG_SCHEMA = cv.All(validate_pillow_installed, FONT_SCHEMA)
def to_code(config):
from PIL import ImageFont
path = CORE.relative_path(config[CONF_FILE])
path = CORE.relative_config_path(config[CONF_FILE])
try:
font = ImageFont.truetype(path, config[CONF_SIZE])
except Exception as e:

2
esphome/components/globals/__init__.py
View File

@ -11,7 +11,7 @@ GlobalsComponent = globals_ns.class_('GlobalsComponent', cg.Component)
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.declare_variable_id(GlobalsComponent),
cv.Required(CONF_ID): cv.declare_id(GlobalsComponent),
cv.Required(CONF_TYPE): cv.string_strict,
cv.Optional(CONF_INITIAL_VALUE): cv.string_strict,
cv.Optional(CONF_RESTORE_VALUE): cv.boolean,

17
esphome/components/gpio/binary_sensor/__init__.py
View File

@ -2,20 +2,21 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import binary_sensor
from esphome.const import CONF_ID, CONF_NAME, CONF_PIN
from esphome.const import CONF_ID, CONF_PIN
from .. import gpio_ns
GPIOBinarySensor = gpio_ns.class_('GPIOBinarySensor', binary_sensor.BinarySensor, cg.Component)
CONFIG_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(GPIOBinarySensor),
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(GPIOBinarySensor),
cv.Required(CONF_PIN): pins.gpio_input_pin_schema
}).extend(cv.COMPONENT_SCHEMA))
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield binary_sensor.register_binary_sensor(var, config)
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
rhs = GPIOBinarySensor.new(config[CONF_NAME], pin)
gpio = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(gpio, config)
yield binary_sensor.register_binary_sensor(gpio, config)
cg.add(var.set_pin(pin))

2
esphome/components/gpio/binary_sensor/gpio_binary_sensor.cpp
View File

@ -19,8 +19,6 @@ void GPIOBinarySensor::dump_config() {
void GPIOBinarySensor::loop() { this->publish_state(this->pin_->digital_read()); }
float GPIOBinarySensor::get_setup_priority() const { return setup_priority::HARDWARE; }
GPIOBinarySensor::GPIOBinarySensor(const std::string &name, GPIOPin *pin)
: binary_sensor::BinarySensor(name), pin_(pin) {}
} // namespace gpio
} // namespace esphome

3
esphome/components/gpio/binary_sensor/gpio_binary_sensor.h
View File

@ -8,8 +8,7 @@ namespace gpio {
class GPIOBinarySensor : public binary_sensor::BinarySensor, public Component {
public:
explicit GPIOBinarySensor(const std::string &name, GPIOPin *pin);
void set_pin(GPIOPin *pin) { pin_ = pin; }
// ========== INTERNAL METHODS ==========
// (In most use cases you won't need these)
/// Setup pin

10
esphome/components/gpio/output/__init__.py
View File

@ -9,13 +9,15 @@ GPIOBinaryOutput = gpio_ns.class_('GPIOBinaryOutput', output.BinaryOutput,
cg.Component)
CONFIG_SCHEMA = output.BINARY_OUTPUT_SCHEMA.extend({
cv.Required(CONF_ID): cv.declare_variable_id(GPIOBinaryOutput),
cv.Required(CONF_ID): cv.declare_id(GPIOBinaryOutput),
cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield output.register_output(var, config)
yield cg.register_component(var, config)
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
gpio = cg.new_Pvariable(config[CONF_ID], pin)
yield output.register_output(gpio, config)
yield cg.register_component(gpio, config)
cg.add(var.set_pin(pin))

2
esphome/components/gpio/output/gpio_binary_output.h
View File

@ -9,7 +9,7 @@ namespace gpio {
class GPIOBinaryOutput : public output::BinaryOutput, public Component {
public:
explicit GPIOBinaryOutput(GPIOPin *pin) : pin_(pin) {}
void set_pin(GPIOPin *pin) { pin_ = pin; }
void setup() override {
this->turn_off();

29
esphome/components/gpio/switch/__init__.py
View File

@ -1,8 +1,8 @@
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import switch
from esphome.const import CONF_ID, CONF_INTERLOCK, CONF_NAME, CONF_PIN, CONF_RESTORE_MODE
from esphome.const import CONF_ID, CONF_INTERLOCK, CONF_PIN, CONF_RESTORE_MODE
from .. import gpio_ns
GPIOSwitch = gpio_ns.class_('GPIOSwitch', switch.Switch, cg.Component)
@ -15,27 +15,28 @@ RESTORE_MODES = {
'ALWAYS_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_ON,
}
CONFIG_SCHEMA = cv.nameable(switch.SWITCH_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(GPIOSwitch),
CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(GPIOSwitch),
cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_RESTORE_MODE, default='RESTORE_DEFAULT_OFF'):
cv.one_of(*RESTORE_MODES, upper=True, space='_'),
cv.Optional(CONF_INTERLOCK): cv.ensure_list(cv.use_variable_id(switch.Switch)),
}).extend(cv.COMPONENT_SCHEMA))
cv.enum(RESTORE_MODES, upper=True, space='_'),
cv.Optional(CONF_INTERLOCK): cv.ensure_list(cv.use_id(switch.Switch)),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
rhs = GPIOSwitch.new(config[CONF_NAME], pin)
gpio = cg.Pvariable(config[CONF_ID], rhs)
yield cg.register_component(gpio, config)
yield switch.register_switch(gpio, config)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield switch.register_switch(var, config)
cg.add(gpio.set_restore_mode(RESTORE_MODES[config[CONF_RESTORE_MODE]]))
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
if CONF_INTERLOCK in config:
interlock = []
for it in config[CONF_INTERLOCK]:
lock = yield cg.get_variable(it)
interlock.append(lock)
cg.add(gpio.set_interlock(interlock))
cg.add(var.set_interlock(interlock))

2
esphome/components/gpio/switch/gpio_switch.cpp
View File

@ -6,8 +6,6 @@ namespace gpio {
static const char *TAG = "switch.gpio";
GPIOSwitch::GPIOSwitch(const std::string &name, GPIOPin *pin) : Switch(name), Component(), pin_(pin) {}
float GPIOSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
void GPIOSwitch::setup() {
ESP_LOGCONFIG(TAG, "Setting up GPIO Switch '%s'...", this->name_.c_str());

2
esphome/components/gpio/switch/gpio_switch.h
View File

@ -15,7 +15,7 @@ enum GPIOSwitchRestoreMode {
class GPIOSwitch : public switch_::Switch, public Component {
public:
GPIOSwitch(const std::string &name, GPIOPin *pin);
void set_pin(GPIOPin *pin) { pin_ = pin; }
void set_restore_mode(GPIOSwitchRestoreMode restore_mode);

3
esphome/components/hdc1080/hdc1080.h
View File

@ -9,9 +9,6 @@ namespace hdc1080 {
class HDC1080Component : public PollingComponent, public i2c::I2CDevice {
public:
/// Initialize the component with the provided update interval.
HDC1080Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }

15
esphome/components/hdc1080/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_CELSIUS, UNIT_PERCENT
ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_CELSIUS, UNIT_PERCENT
DEPENDENCIES = ['i2c']
@ -10,17 +10,14 @@ hdc1080_ns = cg.esphome_ns.namespace('hdc1080')
HDC1080Component = hdc1080_ns.class_('HDC1080Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(HDC1080Component),
cv.Optional(CONF_TEMPERATURE): cv.nameable(
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1)),
cv.Optional(CONF_HUMIDITY): cv.nameable(
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x40))
cv.GenerateID(): cv.declare_id(HDC1080Component),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x40))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

14
esphome/components/hlw8012/hlw8012.cpp
View File

@ -32,17 +32,17 @@ void HLW8012Component::dump_config() {
float HLW8012Component::get_setup_priority() const { return setup_priority::DATA; }
void HLW8012Component::update() {
// HLW8012 has 50% duty cycle
const uint32_t last_rise_cf = this->cf_store_.get_last_rise();
const uint32_t last_rise_cf1 = this->cf1_store_.get_last_rise();
const uint32_t now = micros();
float full_cycle_cf = this->cf_store_.get_pulse_width_s() * 2;
float full_cycle_cf1 = this->cf1_store_.get_pulse_width_s() * 2;
float cf_hz, cf1_hz;
float cf_hz = 0.0f, cf1_hz = 0.0f;
auto update_interval_micros = static_cast<uint32_t>(this->update_interval_ * 1e3f);
if (full_cycle_cf == 0.0f)
cf_hz = 0.0f;
else
if (full_cycle_cf != 0.0f && now - last_rise_cf < update_interval_micros * 3)
cf_hz = 1.0f / full_cycle_cf;
if (full_cycle_cf1 == 0.0f)
cf1_hz = 0.0f;
else
if (full_cycle_cf1 != 0.0f && now - last_rise_cf1 < update_interval_micros * 3)
cf1_hz = 1.0f / full_cycle_cf1;
if (this->nth_value_++ < 2) {

2
esphome/components/hlw8012/hlw8012.h
View File

@ -10,8 +10,6 @@ namespace hlw8012 {
class HLW8012Component : public PollingComponent {
public:
HLW8012Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

17
esphome/components/hlw8012/sensor.py
View File

@ -3,8 +3,8 @@ import esphome.config_validation as cv
from esphome import pins
from esphome.components import sensor
from esphome.const import CONF_CHANGE_MODE_EVERY, CONF_CURRENT, \
CONF_CURRENT_RESISTOR, CONF_ID, CONF_POWER, CONF_SEL_PIN, CONF_UPDATE_INTERVAL, \
CONF_VOLTAGE, CONF_VOLTAGE_DIVIDER, ICON_FLASH, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT
CONF_CURRENT_RESISTOR, CONF_ID, CONF_POWER, CONF_SEL_PIN, CONF_VOLTAGE, CONF_VOLTAGE_DIVIDER, \
ICON_FLASH, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT
AUTO_LOAD = ['pulse_width']
@ -14,26 +14,25 @@ HLW8012Component = hlw8012_ns.class_('HLW8012Component', cg.PollingComponent)
CONF_CF1_PIN = 'cf1_pin'
CONF_CF_PIN = 'cf_pin'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(HLW8012Component),
cv.GenerateID(): cv.declare_id(HLW8012Component),
cv.Required(CONF_SEL_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_CF_PIN): cv.All(pins.internal_gpio_input_pullup_pin_schema,
pins.validate_has_interrupt),
cv.Required(CONF_CF1_PIN): cv.All(pins.internal_gpio_input_pullup_pin_schema,
pins.validate_has_interrupt),
cv.Optional(CONF_VOLTAGE): cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1)),
cv.Optional(CONF_CURRENT): cv.nameable(sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2)),
cv.Optional(CONF_POWER): cv.nameable(sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1)),
cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
cv.Optional(CONF_CURRENT_RESISTOR, default=0.001): cv.resistance,
cv.Optional(CONF_VOLTAGE_DIVIDER, default=2351): cv.positive_float,
cv.Optional(CONF_CHANGE_MODE_EVERY, default=8): cv.All(cv.uint32_t, cv.Range(min=1)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA)
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
sel = yield cg.gpio_pin_expression(config[CONF_SEL_PIN])

2
esphome/components/hmc5883l/hmc5883l.h
View File

@ -20,8 +20,6 @@ enum HMC5883LRange {
class HMC5883LComponent : public PollingComponent, public i2c::I2CDevice {
public:
HMC5883LComponent(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

23
esphome/components/hmc5883l/sensor.py
View File

@ -2,8 +2,8 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_ADDRESS, CONF_ID, CONF_RANGE, CONF_UPDATE_INTERVAL, \
ICON_MAGNET, UNIT_MICROTESLA, UNIT_DEGREES, ICON_SCREEN_ROTATION
from esphome.const import CONF_ADDRESS, CONF_ID, CONF_RANGE, ICON_MAGNET, UNIT_MICROTESLA, \
UNIT_DEGREES, ICON_SCREEN_ROTATION
DEPENDENCIES = ['i2c']
@ -33,30 +33,29 @@ def validate_range(value):
value = cv.string(value)
if value.endswith(u'µT') or value.endswith('uT'):
value = value[:-2]
return cv.one_of(*HMC5883L_RANGES, int=True)(value)
return cv.enum(HMC5883L_RANGES, int=True)(value)
field_strength_schema = sensor.sensor_schema(UNIT_MICROTESLA, ICON_MAGNET, 1)
heading_schema = sensor.sensor_schema(UNIT_DEGREES, ICON_SCREEN_ROTATION, 1)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(HMC5883LComponent),
cv.GenerateID(): cv.declare_id(HMC5883LComponent),
cv.Optional(CONF_ADDRESS): cv.i2c_address,
cv.Optional(CONF_FIELD_STRENGTH_X): cv.nameable(field_strength_schema),
cv.Optional(CONF_FIELD_STRENGTH_Y): cv.nameable(field_strength_schema),
cv.Optional(CONF_FIELD_STRENGTH_Z): cv.nameable(field_strength_schema),
cv.Optional(CONF_HEADING): cv.nameable(heading_schema),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
cv.Optional(CONF_FIELD_STRENGTH_X): field_strength_schema,
cv.Optional(CONF_FIELD_STRENGTH_Y): field_strength_schema,
cv.Optional(CONF_FIELD_STRENGTH_Z): field_strength_schema,
cv.Optional(CONF_HEADING): heading_schema,
cv.Optional(CONF_RANGE, default='130uT'): validate_range,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x1E))
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x1E))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
cg.add(var.set_range(HMC5883L_RANGES[config[CONF_RANGE]]))
cg.add(var.set_range(config[CONF_RANGE]))
if CONF_FIELD_STRENGTH_X in config:
sens = yield sensor.new_sensor(config[CONF_FIELD_STRENGTH_X])
cg.add(var.set_x_sensor(sens))

16
esphome/components/homeassistant/binary_sensor/__init__.py
View File

@ -1,20 +1,22 @@
from esphome.components import binary_sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_ENTITY_ID, CONF_ID
from .. import homeassistant_ns
DEPENDENCIES = ['api']
HomeassistantBinarySensor = homeassistant_ns.class_('HomeassistantBinarySensor',
binary_sensor.BinarySensor)
CONFIG_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(HomeassistantBinarySensor),
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(HomeassistantBinarySensor),
cv.Required(CONF_ENTITY_ID): cv.entity_id,
}).extend(cv.COMPONENT_SCHEMA))
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_ENTITY_ID])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield binary_sensor.register_binary_sensor(var, config)
cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))

2
esphome/components/homeassistant/binary_sensor/homeassistant_binary_sensor.cpp
View File

@ -31,8 +31,6 @@ void HomeassistantBinarySensor::dump_config() {
ESP_LOGCONFIG(TAG, " Entity ID: '%s'", this->entity_id_.c_str());
}
float HomeassistantBinarySensor::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
HomeassistantBinarySensor::HomeassistantBinarySensor(const std::string &name, const std::string &entity_id)
: BinarySensor(name), entity_id_(entity_id) {}
} // namespace homeassistant
} // namespace esphome

2
esphome/components/homeassistant/binary_sensor/homeassistant_binary_sensor.h
View File

@ -8,7 +8,7 @@ namespace homeassistant {
class HomeassistantBinarySensor : public binary_sensor::BinarySensor, public Component {
public:
HomeassistantBinarySensor(const std::string &name, const std::string &entity_id);
void set_entity_id(const std::string &entity_id) { entity_id_ = entity_id; }
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

12
esphome/components/homeassistant/sensor/__init__.py
View File

@ -1,20 +1,22 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
from esphome.const import CONF_ENTITY_ID, CONF_ID, ICON_EMPTY, UNIT_EMPTY
from .. import homeassistant_ns
DEPENDENCIES = ['api']
HomeassistantSensor = homeassistant_ns.class_('HomeassistantSensor', sensor.Sensor)
CONFIG_SCHEMA = cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(HomeassistantSensor),
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 1).extend({
cv.GenerateID(): cv.declare_id(HomeassistantSensor),
cv.Required(CONF_ENTITY_ID): cv.entity_id,
}))
})
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_ENTITY_ID])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))

2
esphome/components/homeassistant/sensor/homeassistant_sensor.cpp
View File

@ -7,8 +7,6 @@ namespace homeassistant {
static const char *TAG = "homeassistant.sensor";
HomeassistantSensor::HomeassistantSensor(const std::string &name, const std::string &entity_id)
: Sensor(name), entity_id_(entity_id) {}
void HomeassistantSensor::setup() {
api::global_api_server->subscribe_home_assistant_state(this->entity_id_, [this](std::string state) {
auto val = parse_float(state);

2
esphome/components/homeassistant/sensor/homeassistant_sensor.h
View File

@ -8,7 +8,7 @@ namespace homeassistant {
class HomeassistantSensor : public sensor::Sensor, public Component {
public:
HomeassistantSensor(const std::string &name, const std::string &entity_id);
void set_entity_id(const std::string &entity_id) { entity_id_ = entity_id; }
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

16
esphome/components/homeassistant/text_sensor/__init__.py
View File

@ -1,7 +1,7 @@
from esphome.components import text_sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
import esphome.config_validation as cv
from esphome.components import text_sensor
from esphome.const import CONF_ENTITY_ID, CONF_ID
from .. import homeassistant_ns
DEPENDENCIES = ['api']
@ -9,13 +9,15 @@ DEPENDENCIES = ['api']
HomeassistantTextSensor = homeassistant_ns.class_('HomeassistantTextSensor',
text_sensor.TextSensor, cg.Component)
CONFIG_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(HomeassistantTextSensor),
CONFIG_SCHEMA = text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(HomeassistantTextSensor),
cv.Required(CONF_ENTITY_ID): cv.entity_id,
}))
})
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_ENTITY_ID])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield text_sensor.register_text_sensor(var, config)
cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))

3
esphome/components/homeassistant/text_sensor/homeassistant_text_sensor.h
View File

@ -8,8 +8,7 @@ namespace homeassistant {
class HomeassistantTextSensor : public text_sensor::TextSensor, public Component {
public:
HomeassistantTextSensor(const std::string &name, const std::string &entity_id)
: TextSensor(name), entity_id_(entity_id) {}
void set_entity_id(const std::string &entity_id) { entity_id_ = entity_id; }
void dump_config() override;
void setup() override;

2
esphome/components/homeassistant/time/__init__.py
View File

@ -9,7 +9,7 @@ DEPENDENCIES = ['api']
HomeassistantTime = homeassistant_ns.class_('HomeassistantTime', time_.RealTimeClock)
CONFIG_SCHEMA = time_.TIME_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(HomeassistantTime),
cv.GenerateID(): cv.declare_id(HomeassistantTime),
}).extend(cv.COMPONENT_SCHEMA)

2
esphome/components/homeassistant/time/homeassistant_time.cpp
View File

@ -14,7 +14,7 @@ float HomeassistantTime::get_setup_priority() const { return setup_priority::DAT
void HomeassistantTime::setup() {
global_homeassistant_time = this;
this->set_interval(15 * 60 * 1000, [this]() {
this->set_interval(15 * 60 * 1000, []() {
// re-request time every 15 minutes
api::global_api_server->request_time();
});

1
esphome/components/htu21d/htu21d.h
View File

@ -9,7 +9,6 @@ namespace htu21d {
class HTU21DComponent : public PollingComponent, public i2c::I2CDevice {
public:
HTU21DComponent(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }

15
esphome/components/htu21d/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, ICON_THERMOMETER, UNIT_CELSIUS, UNIT_PERCENT, ICON_WATER_PERCENT
ICON_THERMOMETER, UNIT_CELSIUS, UNIT_PERCENT, ICON_WATER_PERCENT
DEPENDENCIES = ['i2c']
@ -10,17 +10,14 @@ htu21d_ns = cg.esphome_ns.namespace('htu21d')
HTU21DComponent = htu21d_ns.class_('HTU21DComponent', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(HTU21DComponent),
cv.Required(CONF_TEMPERATURE): cv.nameable(
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1)),
cv.Required(CONF_HUMIDITY): cv.nameable(
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x40))
cv.GenerateID(): cv.declare_id(HTU21DComponent),
cv.Required(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Required(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x40))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

4
esphome/components/hx711/hx711.cpp
View File

@ -58,10 +58,6 @@ bool HX711Sensor::read_sensor_(uint32_t *result) {
*result = data;
return true;
}
HX711Sensor::HX711Sensor(const std::string &name, GPIOPin *dout, GPIOPin *sck, uint32_t update_interval)
: PollingSensorComponent(name, update_interval), dout_pin_(dout), sck_pin_(sck) {}
void HX711Sensor::set_gain(HX711Gain gain) { this->gain_ = gain; }
} // namespace hx711
} // namespace esphome

8
esphome/components/hx711/hx711.h
View File

@ -13,17 +13,17 @@ enum HX711Gain {
HX711_GAIN_64 = 3,
};
class HX711Sensor : public sensor::PollingSensorComponent {
class HX711Sensor : public sensor::Sensor, public PollingComponent {
public:
HX711Sensor(const std::string &name, GPIOPin *dout, GPIOPin *sck, uint32_t update_interval);
void set_dout_pin(GPIOPin *dout_pin) { dout_pin_ = dout_pin; }
void set_sck_pin(GPIOPin *sck_pin) { sck_pin_ = sck_pin; }
void set_gain(HX711Gain gain) { gain_ = gain; }
void setup() override;
void dump_config() override;
float get_setup_priority() const override;
void update() override;
void set_gain(HX711Gain gain);
protected:
bool read_sensor_(uint32_t *result);

27
esphome/components/hx711/sensor.py
View File

@ -1,9 +1,8 @@
import esphome.codegen as cg
import esphome.config_validation as cv
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_CLK_PIN, CONF_GAIN, CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, \
ICON_SCALE
from esphome.const import CONF_CLK_PIN, CONF_GAIN, CONF_ID, ICON_SCALE
hx711_ns = cg.esphome_ns.namespace('hx711')
HX711Sensor = hx711_ns.class_('HX711Sensor', sensor.PollingSensorComponent)
@ -17,21 +16,21 @@ GAINS = {
64: HX711Gain.HX711_GAIN_64,
}
CONFIG_SCHEMA = cv.nameable(sensor.sensor_schema('', ICON_SCALE, 0).extend({
cv.GenerateID(): cv.declare_variable_id(HX711Sensor),
CONFIG_SCHEMA = sensor.sensor_schema('', ICON_SCALE, 0).extend({
cv.GenerateID(): cv.declare_id(HX711Sensor),
cv.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema,
cv.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_GAIN, default=128): cv.one_of(*GAINS, int=True),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA))
cv.Optional(CONF_GAIN, default=128): cv.enum(GAINS, int=True),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
dout_pin = yield cg.gpio_pin_expression(config[CONF_DOUT_PIN])
sck_pin = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], dout_pin, sck_pin,
config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
cg.add(var.set_gain(GAINS[config[CONF_GAIN]]))
dout_pin = yield cg.gpio_pin_expression(config[CONF_DOUT_PIN])
cg.add(var.set_dout_pin(dout_pin))
sck_pin = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_sck_pin(sck_pin))
cg.add(var.set_gain(config[CONF_GAIN]))

23
esphome/components/i2c/__init__.py
View File

@ -11,7 +11,7 @@ I2CDevice = i2c_ns.class_('I2CDevice')
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(I2CComponent),
cv.GenerateID(): cv.declare_id(I2CComponent),
cv.Optional(CONF_SDA, default='SDA'): pins.input_pin,
cv.Optional(CONF_SCL, default='SCL'): pins.input_pin,
cv.Optional(CONF_FREQUENCY, default='50kHz'):
@ -21,17 +21,26 @@ CONFIG_SCHEMA = cv.Schema({
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_SDA], config[CONF_SCL],
int(config[CONF_FREQUENCY]), config[CONF_SCAN])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(var.set_sda_pin(config[CONF_SDA]))
cg.add(var.set_scl_pin(config[CONF_SCL]))
cg.add(var.set_frequency(int(config[CONF_FREQUENCY])))
cg.add(var.set_scan(config[CONF_SCAN]))
cg.add_library('Wire', None)
cg.add_global(i2c_ns.using)
def i2c_device_schema(default_address):
"""Create a schema for a i2c device.
:param default_address: The default address of the i2c device, can be None to represent
a required option.
:return: The i2c device schema, `extend` this in your config schema.
"""
schema = {
cv.GenerateID(CONF_I2C_ID): cv.use_variable_id(I2CComponent),
cv.GenerateID(CONF_I2C_ID): cv.use_id(I2CComponent),
}
if default_address is None:
schema[cv.Required(CONF_ADDRESS)] = cv.i2c_address
@ -42,6 +51,12 @@ def i2c_device_schema(default_address):
@coroutine
def register_i2c_device(var, config):
"""Register an i2c device with the given config.
Sets the i2c bus to use and the i2c address.
This is a coroutine, you need to await it with a 'yield' expression!
"""
parent = yield cg.get_variable(config[CONF_I2C_ID])
cg.add(var.set_i2c_parent(parent))
cg.add(var.set_i2c_address(config[CONF_ADDRESS]))

3
esphome/components/i2c/i2c.cpp
View File

@ -8,8 +8,7 @@ namespace i2c {
static const char *TAG = "i2c";
I2CComponent::I2CComponent(uint8_t sda_pin, uint8_t scl_pin, uint32_t frequency, bool scan)
: sda_pin_(sda_pin), scl_pin_(scl_pin), frequency_(frequency), scan_(scan) {
I2CComponent::I2CComponent() {
#ifdef ARDUINO_ARCH_ESP32
if (next_i2c_bus_num_ == 0)
this->wire_ = &Wire;

6
esphome/components/i2c/i2c.h
View File

@ -25,7 +25,11 @@ namespace i2c {
*/
class I2CComponent : public Component {
public:
I2CComponent(uint8_t sda_pin, uint8_t scl_pin, uint32_t frequency, bool scan);
I2CComponent();
void set_sda_pin(uint8_t sda_pin) { sda_pin_ = sda_pin; }
void set_scl_pin(uint8_t scl_pin) { scl_pin_ = scl_pin; }
void set_frequency(uint32_t frequency) { frequency_ = frequency; }
void set_scan(bool scan) { scan_ = scan; }
/** Read len amount of bytes from a register into data. Optionally with a conversion time after
* writing the register value to the bus.

6
esphome/components/image/__init__.py
View File

@ -17,10 +17,10 @@ Image_ = display.display_ns.class_('Image')
CONF_RAW_DATA_ID = 'raw_data_id'
IMAGE_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.declare_variable_id(Image_),
cv.Required(CONF_ID): cv.declare_id(Image_),
cv.Required(CONF_FILE): cv.file_,
cv.Optional(CONF_RESIZE): cv.dimensions,
cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(cg.uint8),
cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
})
CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, IMAGE_SCHEMA)
@ -29,7 +29,7 @@ CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, IMAGE_SCHEMA)
def to_code(config):
from PIL import Image
path = CORE.relative_path(config[CONF_FILE])
path = CORE.relative_config_path(config[CONF_FILE])
try:
image = Image.open(path)
except Exception as e:

1
esphome/components/ina219/ina219.h
View File

@ -9,7 +9,6 @@ namespace ina219 {
class INA219Component : public PollingComponent, public i2c::I2CDevice {
public:
INA219Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

17
esphome/components/ina219/sensor.py
View File

@ -4,7 +4,7 @@ import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, \
CONF_MAX_CURRENT, CONF_MAX_VOLTAGE, CONF_POWER, CONF_SHUNT_RESISTANCE, \
CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL, ICON_FLASH, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT
CONF_SHUNT_VOLTAGE, ICON_FLASH, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT
DEPENDENCIES = ['i2c']
@ -12,21 +12,20 @@ ina219_ns = cg.esphome_ns.namespace('ina219')
INA219Component = ina219_ns.class_('INA219Component', cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(INA219Component),
cv.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2)),
cv.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2)),
cv.Optional(CONF_CURRENT): cv.nameable(sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 3)),
cv.Optional(CONF_POWER): cv.nameable(sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 2)),
cv.GenerateID(): cv.declare_id(INA219Component),
cv.Optional(CONF_BUS_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
cv.Optional(CONF_SHUNT_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 3),
cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 2),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1): cv.All(cv.resistance,
cv.Range(min=0.0, max=32.0)),
cv.Optional(CONF_MAX_VOLTAGE, default=32.0): cv.All(cv.voltage, cv.Range(min=0.0, max=32.0)),
cv.Optional(CONF_MAX_CURRENT, default=3.2): cv.All(cv.current, cv.Range(min=0.0)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x40))
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x40))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

1
esphome/components/ina3221/ina3221.h
View File

@ -9,7 +9,6 @@ namespace ina3221 {
class INA3221Component : public PollingComponent, public i2c::I2CDevice {
public:
INA3221Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;
void update() override;

17
esphome/components/ina3221/sensor.py
View File

@ -3,7 +3,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, CONF_POWER, \
CONF_SHUNT_RESISTANCE, CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL, ICON_FLASH, \
CONF_SHUNT_RESISTANCE, CONF_SHUNT_VOLTAGE, ICON_FLASH, \
UNIT_VOLT, UNIT_AMPERE, UNIT_WATT
DEPENDENCIES = ['i2c']
@ -16,25 +16,24 @@ ina3221_ns = cg.esphome_ns.namespace('ina3221')
INA3221Component = ina3221_ns.class_('INA3221Component', cg.PollingComponent, i2c.I2CDevice)
INA3221_CHANNEL_SCHEMA = cv.Schema({
cv.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2)),
cv.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2)),
cv.Optional(CONF_CURRENT): cv.nameable(sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2)),
cv.Optional(CONF_POWER): cv.nameable(sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 2)),
cv.Optional(CONF_BUS_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
cv.Optional(CONF_SHUNT_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 2),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1): cv.All(cv.resistance,
cv.Range(min=0.0, max=32.0)),
})
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(INA3221Component),
cv.GenerateID(): cv.declare_id(INA3221Component),
cv.Optional(CONF_CHANNEL_1): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_CHANNEL_2): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_CHANNEL_3): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x40))
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x40))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

9
esphome/components/interval/__init__.py
View File

@ -4,16 +4,19 @@ from esphome import automation
from esphome.const import CONF_ID, CONF_INTERVAL
interval_ns = cg.esphome_ns.namespace('interval')
IntervalTrigger = interval_ns.class_('IntervalTrigger', cg.Trigger.template(), cg.PollingComponent)
IntervalTrigger = interval_ns.class_('IntervalTrigger', automation.Trigger.template(),
cg.PollingComponent)
CONFIG_SCHEMA = automation.validate_automation(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(IntervalTrigger),
cv.GenerateID(): cv.declare_id(IntervalTrigger),
cv.Required(CONF_INTERVAL): cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA))
def to_code(config):
for conf in config:
var = cg.new_Pvariable(conf[CONF_ID], conf[CONF_INTERVAL])
var = cg.new_Pvariable(conf[CONF_ID])
yield cg.register_component(var, conf)
yield automation.build_automation(var, [], conf)
cg.add(var.set_update_interval(conf[CONF_INTERVAL]))

1
esphome/components/interval/interval.h
View File

@ -8,7 +8,6 @@ namespace interval {
class IntervalTrigger : public Trigger<>, public PollingComponent {
public:
IntervalTrigger(uint32_t update_interval) : PollingComponent(update_interval) {}
void update() override { this->trigger(); }
float get_setup_priority() const override { return setup_priority::DATA; }
};

5
esphome/components/lcd_base/__init__.py
View File

@ -1,7 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import display
from esphome.const import CONF_DIMENSIONS, CONF_LAMBDA, CONF_UPDATE_INTERVAL
from esphome.const import CONF_DIMENSIONS, CONF_LAMBDA
from esphome.core import coroutine
lcd_base_ns = cg.esphome_ns.namespace('lcd_base')
@ -20,8 +20,7 @@ def validate_lcd_dimensions(value):
LCD_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
cv.Required(CONF_DIMENSIONS): validate_lcd_dimensions,
cv.Optional(CONF_UPDATE_INTERVAL, default='1s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA)
}).extend(cv.polling_component_schema('1s'))
@coroutine

2
esphome/components/lcd_base/lcd_display.h
View File

@ -16,8 +16,6 @@ using lcd_writer_t = std::function<void(LCDDisplay &)>;
class LCDDisplay : public PollingComponent {
public:
LCDDisplay(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_writer(lcd_writer_t &&writer) { this->writer_ = std::move(writer); }
void set_dimensions(uint8_t columns, uint8_t rows) {
this->columns_ = columns;

7
esphome/components/lcd_gpio/display.py
View File

@ -2,8 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import lcd_base
from esphome.const import CONF_DATA_PINS, CONF_ENABLE_PIN, CONF_RS_PIN, CONF_RW_PIN, CONF_ID, \
CONF_UPDATE_INTERVAL
from esphome.const import CONF_DATA_PINS, CONF_ENABLE_PIN, CONF_RS_PIN, CONF_RW_PIN, CONF_ID
AUTO_LOAD = ['lcd_base']
@ -19,7 +18,7 @@ def validate_pin_length(value):
CONFIG_SCHEMA = lcd_base.LCD_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(GPIOLCDDisplay),
cv.GenerateID(): cv.declare_id(GPIOLCDDisplay),
cv.Required(CONF_DATA_PINS): cv.All([pins.gpio_output_pin_schema], validate_pin_length),
cv.Required(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_RS_PIN): pins.gpio_output_pin_schema,
@ -28,7 +27,7 @@ CONFIG_SCHEMA = lcd_base.LCD_SCHEMA.extend({
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield lcd_base.setup_lcd_display(var, config)
pins_ = []
for conf in config[CONF_DATA_PINS]:

2
esphome/components/lcd_gpio/gpio_lcd_display.h
View File

@ -8,8 +8,6 @@ namespace lcd_gpio {
class GPIOLCDDisplay : public lcd_base::LCDDisplay {
public:
GPIOLCDDisplay(uint32_t update_interval) : LCDDisplay(update_interval) {}
void setup() override;
void set_data_pins(GPIOPin *d0, GPIOPin *d1, GPIOPin *d2, GPIOPin *d3) {
this->data_pins_[0] = d0;

6
esphome/components/lcd_pcf8574/display.py
View File

@ -1,7 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import lcd_base, i2c
from esphome.const import CONF_ID, CONF_UPDATE_INTERVAL
from esphome.const import CONF_ID
DEPENDENCIES = ['i2c']
AUTO_LOAD = ['lcd_base']
@ -10,11 +10,11 @@ lcd_pcf8574_ns = cg.esphome_ns.namespace('lcd_pcf8574')
PCF8574LCDDisplay = lcd_pcf8574_ns.class_('PCF8574LCDDisplay', lcd_base.LCDDisplay, i2c.I2CDevice)
CONFIG_SCHEMA = lcd_base.LCD_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(PCF8574LCDDisplay),
cv.GenerateID(): cv.declare_id(PCF8574LCDDisplay),
}).extend(i2c.i2c_device_schema(0x3F))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield lcd_base.setup_lcd_display(var, config)
yield i2c.register_i2c_device(var, config)

1
esphome/components/lcd_pcf8574/pcf8574_display.h
View File

@ -9,7 +9,6 @@ namespace lcd_pcf8574 {
class PCF8574LCDDisplay : public lcd_base::LCDDisplay, public i2c::I2CDevice {
public:
PCF8574LCDDisplay(uint32_t update_interval) : lcd_base::LCDDisplay(update_interval) {}
void setup() override;
void dump_config() override;

2
esphome/components/ledc/output.py
View File

@ -22,7 +22,7 @@ ledc_ns = cg.esphome_ns.namespace('ledc')
LEDCOutput = ledc_ns.class_('LEDCOutput', output.FloatOutput, cg.Component)
CONFIG_SCHEMA = cv.All(output.FLOAT_OUTPUT_SCHEMA.extend({
cv.Required(CONF_ID): cv.declare_variable_id(LEDCOutput),
cv.Required(CONF_ID): cv.declare_id(LEDCOutput),
cv.Required(CONF_PIN): pins.internal_gpio_output_pin_schema,
cv.Optional(CONF_FREQUENCY, default='1kHz'): cv.frequency,
cv.Optional(CONF_BIT_DEPTH, default=12): cv.All(cv.int_, cv.Range(min=1, max=15)),

141
esphome/components/light/__init__.py
View File

@ -1,6 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.automation import ACTION_REGISTRY, maybe_simple_id
from esphome import automation
from esphome.automation import maybe_simple_id
from esphome.components import mqtt
from esphome.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLORS, CONF_COLOR_CORRECT, \
CONF_COLOR_TEMPERATURE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_DURATION, CONF_EFFECT, \
@ -9,7 +10,7 @@ from esphome.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLORS, C
CONF_SPEED, CONF_STATE, CONF_TRANSITION_LENGTH, CONF_UPDATE_INTERVAL, CONF_WHITE, CONF_WIDTH, \
CONF_MQTT_ID
from esphome.core import coroutine
from esphome.util import ServiceRegistry
from esphome.util import Registry
IS_PLATFORM_COMPONENT = True
@ -23,8 +24,8 @@ AddressableLight = light_ns.class_('AddressableLight')
AddressableLightRef = AddressableLight.operator('ref')
# Actions
ToggleAction = light_ns.class_('ToggleAction', cg.Action)
LightControlAction = light_ns.class_('LightControlAction', cg.Action)
ToggleAction = light_ns.class_('ToggleAction', automation.Action)
LightControlAction = light_ns.class_('LightControlAction', automation.Action)
LightColorValues = light_ns.class_('LightColorValues')
@ -78,27 +79,24 @@ ADDRESSABLE_EFFECTS = RGB_EFFECTS + [CONF_ADDRESSABLE_LAMBDA, CONF_ADDRESSABLE_R
CONF_ADDRESSABLE_TWINKLE, CONF_ADDRESSABLE_RANDOM_TWINKLE,
CONF_ADDRESSABLE_FIREWORKS, CONF_ADDRESSABLE_FLICKER]
EFFECTS_REGISTRY = ServiceRegistry()
EFFECTS_REGISTRY = Registry()
def register_effect(name, effect_type, default_name, schema, *extra_validators):
schema = cv.Schema(schema).extend({
cv.GenerateID(): cv.declare_variable_id(effect_type),
cv.Optional(CONF_NAME, default=default_name): cv.string_strict,
})
validator = cv.All(schema, *extra_validators)
register = EFFECTS_REGISTRY.register(name, validator)
return register
return EFFECTS_REGISTRY.register(name, effect_type, validator)
@register_effect('lambda', LambdaLightEffect, "Lambda", {
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.update_interval,
})
def lambda_effect_to_code(config):
def lambda_effect_to_code(config, effect_id):
lambda_ = yield cg.process_lambda(config[CONF_LAMBDA], [], return_type=cg.void)
yield cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], lambda_,
yield cg.new_Pvariable(effect_id, config[CONF_NAME], lambda_,
config[CONF_UPDATE_INTERVAL])
@ -106,8 +104,8 @@ def lambda_effect_to_code(config):
cv.Optional(CONF_TRANSITION_LENGTH, default='7.5s'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_UPDATE_INTERVAL, default='10s'): cv.positive_time_period_milliseconds,
})
def random_effect_to_code(config):
effect = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def random_effect_to_code(config, effect_id):
effect = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(effect.set_transition_length(config[CONF_TRANSITION_LENGTH]))
cg.add(effect.set_update_interval(config[CONF_UPDATE_INTERVAL]))
yield effect
@ -128,8 +126,8 @@ def random_effect_to_code(config):
}), cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE,
CONF_WHITE)), cv.Length(min=2)),
})
def strobe_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def strobe_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
colors = []
for color in config.get(CONF_COLORS, []):
colors.append(cg.StructInitializer(
@ -147,8 +145,8 @@ def strobe_effect_to_code(config):
cv.Optional(CONF_ALPHA, default=0.95): cv.percentage,
cv.Optional(CONF_INTENSITY, default=0.015): cv.percentage,
})
def flicker_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def flicker_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_alpha(config[CONF_ALPHA]))
cg.add(var.set_intensity(config[CONF_INTENSITY]))
yield var
@ -158,10 +156,10 @@ def flicker_effect_to_code(config):
cv.Required(CONF_LAMBDA): cv.lambda_,
cv.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
})
def addressable_lambda_effect_to_code(config):
def addressable_lambda_effect_to_code(config, effect_id):
args = [(AddressableLightRef, 'it')]
lambda_ = yield cg.process_lambda(config[CONF_LAMBDA], args, return_type=cg.void)
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], lambda_,
var = cg.new_Pvariable(effect_id, config[CONF_NAME], lambda_,
config[CONF_UPDATE_INTERVAL])
yield var
@ -170,8 +168,8 @@ def addressable_lambda_effect_to_code(config):
cv.Optional(CONF_SPEED, default=10): cv.uint32_t,
cv.Optional(CONF_WIDTH, default=50): cv.uint32_t,
})
def addressable_rainbow_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_rainbow_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_speed(config[CONF_SPEED]))
cg.add(var.set_width(config[CONF_WIDTH]))
yield var
@ -189,8 +187,8 @@ def addressable_rainbow_effect_to_code(config):
cv.Optional(CONF_ADD_LED_INTERVAL, default='0.1s'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_REVERSE, default=False): cv.boolean,
})
def addressable_color_wipe_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_color_wipe_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
cg.add(var.set_reverse(config[CONF_REVERSE]))
colors = []
@ -211,8 +209,8 @@ def addressable_color_wipe_effect_to_code(config):
@register_effect('addressable_scan', AddressableScanEffect, "Scan", {
cv.Optional(CONF_MOVE_INTERVAL, default='0.1s'): cv.positive_time_period_milliseconds,
})
def addressable_scan_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_scan_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_move_interval(config[CONF_MOVE_INTERVAL]))
yield var
@ -221,8 +219,8 @@ def addressable_scan_effect_to_code(config):
cv.Optional(CONF_TWINKLE_PROBABILITY, default='5%'): cv.percentage,
cv.Optional(CONF_PROGRESS_INTERVAL, default='4ms'): cv.positive_time_period_milliseconds,
})
def addressable_twinkle_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_twinkle_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
cg.add(var.set_progress_interval(config[CONF_PROGRESS_INTERVAL]))
yield var
@ -232,8 +230,8 @@ def addressable_twinkle_effect_to_code(config):
cv.Optional(CONF_TWINKLE_PROBABILITY, default='5%'): cv.percentage,
cv.Optional(CONF_PROGRESS_INTERVAL, default='32ms'): cv.positive_time_period_milliseconds,
})
def addressable_random_twinkle_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_random_twinkle_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
cg.add(var.set_progress_interval(config[CONF_PROGRESS_INTERVAL]))
yield var
@ -245,8 +243,8 @@ def addressable_random_twinkle_effect_to_code(config):
cv.Optional(CONF_USE_RANDOM_COLOR, default=False): cv.boolean,
cv.Optional(CONF_FADE_OUT_RATE, default=120): cv.uint8_t,
})
def addressable_fireworks_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_fireworks_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
cg.add(var.set_spark_probability(config[CONF_SPARK_PROBABILITY]))
cg.add(var.set_use_random_color(config[CONF_USE_RANDOM_COLOR]))
@ -258,8 +256,8 @@ def addressable_fireworks_effect_to_code(config):
cv.Optional(CONF_UPDATE_INTERVAL, default='16ms'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_INTENSITY, default='5%'): cv.percentage,
})
def addressable_flicker_effect_to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
def addressable_flicker_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
cg.add(var.set_intensity(config[CONF_INTENSITY]))
yield var
@ -267,7 +265,7 @@ def addressable_flicker_effect_to_code(config):
def validate_effects(allowed_effects):
def validator(value):
value = cv.validate_registry('effect', EFFECTS_REGISTRY, [])(value)
value = cv.validate_registry('effect', EFFECTS_REGISTRY)(value)
errors = []
names = set()
for i, x in enumerate(value):
@ -294,8 +292,8 @@ def validate_effects(allowed_effects):
LIGHT_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(LightState),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_variable_id(mqtt.MQTTJSONLightComponent),
cv.GenerateID(): cv.declare_id(LightState),
cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTJSONLightComponent),
})
BINARY_LIGHT_SCHEMA = LIGHT_SCHEMA.extend({
@ -313,7 +311,7 @@ RGB_LIGHT_SCHEMA = BRIGHTNESS_ONLY_LIGHT_SCHEMA.extend({
})
ADDRESSABLE_LIGHT_SCHEMA = RGB_LIGHT_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(AddressableLightState),
cv.GenerateID(): cv.declare_id(AddressableLightState),
cv.Optional(CONF_EFFECTS): validate_effects(ADDRESSABLE_EFFECTS),
cv.Optional(CONF_COLOR_CORRECT): cv.All([cv.percentage], cv.Length(min=3, max=4)),
})
@ -346,38 +344,21 @@ def register_light(output_var, config):
yield setup_light_core_(light_var, output_var, config)
@ACTION_REGISTRY.register('light.toggle', maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(LightState),
@automation.register_action('light.toggle', ToggleAction, maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(LightState),
cv.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
}))
def light_toggle_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = ToggleAction.template(template_arg)
rhs = type.new(var)
action = cg.Pvariable(action_id, rhs, type=type)
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_TRANSITION_LENGTH in config:
template_ = yield cg.templatable(config[CONF_TRANSITION_LENGTH], args, cg.uint32)
cg.add(action.set_transition_length(template_))
yield action
@ACTION_REGISTRY.register('light.turn_off', maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(LightState),
cv.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
}))
def light_turn_off_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = LightControlAction.template(template_arg)
rhs = type.new(var)
action = cg.Pvariable(action_id, rhs, type=type)
if CONF_TRANSITION_LENGTH in config:
template_ = yield cg.templatable(config[CONF_TRANSITION_LENGTH], args, cg.uint32)
cg.add(action.set_transition_length(template_))
yield action
cg.add(var.set_transition_length(template_))
yield var
LIGHT_CONTROL_ACTION_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.use_variable_id(LightState),
cv.Required(CONF_ID): cv.use_id(LightState),
cv.Optional(CONF_STATE): cv.templatable(cv.boolean),
cv.Exclusive(CONF_TRANSITION_LENGTH, 'transformer'):
cv.templatable(cv.positive_time_period_milliseconds),
@ -392,7 +373,7 @@ LIGHT_CONTROL_ACTION_SCHEMA = cv.Schema({
cv.Optional(CONF_COLOR_TEMPERATURE): cv.templatable(cv.color_temperature),
})
LIGHT_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID): cv.use_variable_id(LightState),
cv.Required(CONF_ID): cv.use_id(LightState),
cv.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
cv.Optional(CONF_STATE, default=False): False,
})
@ -401,45 +382,43 @@ LIGHT_TURN_ON_ACTION_SCHEMA = maybe_simple_id(LIGHT_CONTROL_ACTION_SCHEMA.extend
}))
@ACTION_REGISTRY.register('light.turn_off', LIGHT_TURN_OFF_ACTION_SCHEMA)
@ACTION_REGISTRY.register('light.turn_on', LIGHT_TURN_ON_ACTION_SCHEMA)
@ACTION_REGISTRY.register('light.control', LIGHT_CONTROL_ACTION_SCHEMA)
def light_control_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])
type = LightControlAction.template(template_arg)
rhs = type.new(var)
action = cg.Pvariable(action_id, rhs, type=type)
@automation.register_action('light.turn_off', LightControlAction, LIGHT_TURN_OFF_ACTION_SCHEMA)
@automation.register_action('light.turn_on', LightControlAction, LIGHT_TURN_ON_ACTION_SCHEMA)
@automation.register_action('light.control', LightControlAction, LIGHT_CONTROL_ACTION_SCHEMA)
def light_control_to_code(config, var, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(var, template_arg, paren)
if CONF_STATE in config:
template_ = yield cg.templatable(config[CONF_STATE], args, bool)
cg.add(action.set_state(template_))
cg.add(var.set_state(template_))
if CONF_TRANSITION_LENGTH in config:
template_ = yield cg.templatable(config[CONF_TRANSITION_LENGTH], args, cg.uint32)
cg.add(action.set_transition_length(template_))
cg.add(var.set_transition_length(template_))
if CONF_FLASH_LENGTH in config:
template_ = yield cg.templatable(config[CONF_FLASH_LENGTH], args, cg.uint32)
cg.add(action.set_flash_length(template_))
cg.add(var.set_flash_length(template_))
if CONF_BRIGHTNESS in config:
template_ = yield cg.templatable(config[CONF_BRIGHTNESS], args, float)
cg.add(action.set_brightness(template_))
cg.add(var.set_brightness(template_))
if CONF_RED in config:
template_ = yield cg.templatable(config[CONF_RED], args, float)
cg.add(action.set_red(template_))
cg.add(var.set_red(template_))
if CONF_GREEN in config:
template_ = yield cg.templatable(config[CONF_GREEN], args, float)
cg.add(action.set_green(template_))
cg.add(var.set_green(template_))
if CONF_BLUE in config:
template_ = yield cg.templatable(config[CONF_BLUE], args, float)
cg.add(action.set_blue(template_))
cg.add(var.set_blue(template_))
if CONF_WHITE in config:
template_ = yield cg.templatable(config[CONF_WHITE], args, float)
cg.add(action.set_white(template_))
cg.add(var.set_white(template_))
if CONF_COLOR_TEMPERATURE in config:
template_ = yield cg.templatable(config[CONF_COLOR_TEMPERATURE], args, float)
cg.add(action.set_color_temperature(template_))
cg.add(var.set_color_temperature(template_))
if CONF_EFFECT in config:
template_ = yield cg.templatable(config[CONF_EFFECT], args, cg.std_string)
cg.add(action.set_effect(template_))
yield action
cg.add(var.set_effect(template_))
yield var
def to_code(config):

2
esphome/components/light/automation.h
View File

@ -16,7 +16,6 @@ template<typename... Ts> class ToggleAction : public Action<Ts...> {
auto call = this->state_->toggle();
call.set_transition_length(this->transition_length_.optional_value(x...));
call.perform();
this->play_next(x...);
}
protected:
@ -51,7 +50,6 @@ template<typename... Ts> class LightControlAction : public Action<Ts...> {
call.set_flash_length(this->flash_length_.optional_value(x...));
call.set_transition_length(this->transition_length_.optional_value(x...));
call.perform();
this->play_next(x...);
}
protected:

11
esphome/components/logger/__init__.py
View File

@ -2,7 +2,8 @@ import re
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.automation import ACTION_REGISTRY, LambdaAction
from esphome import automation
from esphome.automation import LambdaAction
from esphome.const import CONF_ARGS, CONF_BAUD_RATE, CONF_FORMAT, CONF_HARDWARE_UART, CONF_ID, \
CONF_LEVEL, CONF_LOGS, CONF_TAG, CONF_TX_BUFFER_SIZE
from esphome.core import CORE, EsphomeError, Lambda, coroutine_with_priority
@ -71,7 +72,7 @@ def validate_local_no_higher_than_global(value):
Logger = logger_ns.class_('Logger', cg.Component)
CONFIG_SCHEMA = cv.All(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(Logger),
cv.GenerateID(): cv.declare_id(Logger),
cv.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
cv.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
cv.Optional(CONF_HARDWARE_UART, default='UART0'): uart_selection,
@ -172,7 +173,7 @@ LOGGER_LOG_ACTION_SCHEMA = cv.All(maybe_simple_message({
}), validate_printf)
@ACTION_REGISTRY.register(CONF_LOGGER_LOG, LOGGER_LOG_ACTION_SCHEMA)
@automation.register_action(CONF_LOGGER_LOG, LambdaAction, LOGGER_LOG_ACTION_SCHEMA)
def logger_log_action_to_code(config, action_id, template_arg, args):
esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
args_ = [cg.RawExpression(text_type(x)) for x in config[CONF_ARGS]]
@ -180,6 +181,4 @@ def logger_log_action_to_code(config, action_id, template_arg, args):
text = text_type(cg.statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args_)))
lambda_ = yield cg.process_lambda(Lambda(text), args, return_type=cg.void)
rhs = LambdaAction.new(template_arg, lambda_)
type = LambdaAction.template(template_arg)
yield cg.Pvariable(action_id, rhs, type=type)
yield cg.new_Pvariable(action_id, template_arg, lambda_)

3
esphome/components/max31855/max31855.cpp
View File

@ -6,9 +6,6 @@ namespace max31855 {
static const char *TAG = "max31855";
MAX31855Sensor::MAX31855Sensor(const std::string &name, uint32_t update_interval)
: PollingSensorComponent(name, update_interval) {}
void MAX31855Sensor::update() {
this->enable();
delay(1);

4
esphome/components/max31855/max31855.h
View File

@ -7,10 +7,8 @@
namespace esphome {
namespace max31855 {
class MAX31855Sensor : public sensor::PollingSensorComponent, public spi::SPIDevice {
class MAX31855Sensor : public sensor::Sensor, public PollingComponent, public spi::SPIDevice {
public:
MAX31855Sensor(const std::string &name, uint32_t update_interval);
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

13
esphome/components/max31855/sensor.py
View File

@ -1,21 +1,18 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor, spi
from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, \
ICON_THERMOMETER, UNIT_CELSIUS
from esphome.const import CONF_ID, ICON_THERMOMETER, UNIT_CELSIUS
max31855_ns = cg.esphome_ns.namespace('max31855')
MAX31855Sensor = max31855_ns.class_('MAX31855Sensor', sensor.PollingSensorComponent, spi.SPIDevice)
CONFIG_SCHEMA = cv.nameable(
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.GenerateID(): cv.declare_variable_id(MAX31855Sensor),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.SPI_DEVICE_SCHEMA))
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.GenerateID(): cv.declare_id(MAX31855Sensor),
}).extend(cv.polling_component_schema('60s')).extend(spi.SPI_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
yield sensor.register_sensor(var, config)

3
esphome/components/max6675/max6675.cpp
View File

@ -6,9 +6,6 @@ namespace max6675 {
static const char *TAG = "max6675";
MAX6675Sensor::MAX6675Sensor(const std::string &name, uint32_t update_interval)
: PollingSensorComponent(name, update_interval) {}
void MAX6675Sensor::update() {
this->enable();
delay(1);

4
esphome/components/max6675/max6675.h
View File

@ -7,10 +7,8 @@
namespace esphome {
namespace max6675 {
class MAX6675Sensor : public sensor::PollingSensorComponent, public spi::SPIDevice {
class MAX6675Sensor : public sensor::Sensor, public PollingComponent, public spi::SPIDevice {
public:
MAX6675Sensor(const std::string &name, uint32_t update_interval);
void setup() override;
void dump_config() override;
float get_setup_priority() const override;

12
esphome/components/max6675/sensor.py
View File

@ -1,21 +1,19 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor, spi
from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ICON_THERMOMETER, UNIT_CELSIUS
from esphome.const import CONF_ID, ICON_THERMOMETER, UNIT_CELSIUS
max6675_ns = cg.esphome_ns.namespace('max6675')
MAX6675Sensor = max6675_ns.class_('MAX6675Sensor', sensor.PollingSensorComponent,
spi.SPIDevice)
CONFIG_SCHEMA = cv.nameable(
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.GenerateID(): cv.declare_variable_id(MAX6675Sensor),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.SPI_DEVICE_SCHEMA))
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.GenerateID(): cv.declare_id(MAX6675Sensor),
}).extend(cv.polling_component_schema('60s')).extend(spi.SPI_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
yield sensor.register_sensor(var, config)

9
esphome/components/max7219/display.py
View File

@ -1,7 +1,7 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import display, spi
from esphome.const import CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, CONF_UPDATE_INTERVAL
from esphome.const import CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS
DEPENDENCIES = ['spi']
@ -10,16 +10,15 @@ MAX7219Component = max7219_ns.class_('MAX7219Component', cg.PollingComponent, sp
MAX7219ComponentRef = MAX7219Component.operator('ref')
CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MAX7219Component),
cv.GenerateID(): cv.declare_id(MAX7219Component),
cv.Optional(CONF_UPDATE_INTERVAL, default='1s'): cv.update_interval,
cv.Optional(CONF_NUM_CHIPS, default=1): cv.All(cv.uint8_t, cv.Range(min=1)),
cv.Optional(CONF_INTENSITY, default=15): cv.All(cv.uint8_t, cv.Range(min=0, max=15)),
}).extend(cv.COMPONENT_SCHEMA).extend(spi.SPI_DEVICE_SCHEMA)
}).extend(cv.polling_component_schema('1s')).extend(spi.SPI_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
yield display.register_display(var, config)

2
esphome/components/max7219/max7219.h
View File

@ -18,8 +18,6 @@ using max7219_writer_t = std::function<void(MAX7219Component &)>;
class MAX7219Component : public PollingComponent, public spi::SPIDevice {
public:
MAX7219Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void set_writer(max7219_writer_t &&writer);
void setup() override;

13
esphome/components/mcp23017/__init__.py
View File

@ -19,7 +19,7 @@ MCP23017 = mcp23017_ns.class_('MCP23017', cg.Component, i2c.I2CDevice)
MCP23017GPIOPin = mcp23017_ns.class_('MCP23017GPIOPin', cg.GPIOPin)
CONFIG_SCHEMA = cv.Schema({
cv.Required(CONF_ID): cv.declare_variable_id(MCP23017),
cv.Required(CONF_ID): cv.declare_id(MCP23017),
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x20))
@ -31,15 +31,15 @@ def to_code(config):
CONF_MCP23017 = 'mcp23017'
MCP23017_OUTPUT_PIN_SCHEMA = cv.Schema({
cv.Required(CONF_MCP23017): cv.use_variable_id(MCP23017),
cv.Required(CONF_MCP23017): cv.use_id(MCP23017),
cv.Required(CONF_NUMBER): cv.int_,
cv.Optional(CONF_MODE, default="OUTPUT"): cv.one_of(*MCP23017_GPIO_MODES, upper=True),
cv.Optional(CONF_MODE, default="OUTPUT"): cv.enum(MCP23017_GPIO_MODES, upper=True),
cv.Optional(CONF_INVERTED, default=False): cv.boolean,
})
MCP23017_INPUT_PIN_SCHEMA = cv.Schema({
cv.Required(CONF_MCP23017): cv.use_variable_id(MCP23017),
cv.Required(CONF_MCP23017): cv.use_id(MCP23017),
cv.Required(CONF_NUMBER): cv.int_,
cv.Optional(CONF_MODE, default="INPUT"): cv.one_of(*MCP23017_GPIO_MODES, upper=True),
cv.Optional(CONF_MODE, default="INPUT"): cv.enum(MCP23017_GPIO_MODES, upper=True),
cv.Optional(CONF_INVERTED, default=False): cv.boolean,
})
@ -48,5 +48,4 @@ MCP23017_INPUT_PIN_SCHEMA = cv.Schema({
(MCP23017_OUTPUT_PIN_SCHEMA, MCP23017_INPUT_PIN_SCHEMA))
def mcp23017_pin_to_code(config):
parent = yield cg.get_variable(config[CONF_MCP23017])
yield MCP23017GPIOPin.new(parent, config[CONF_NUMBER],
MCP23017_GPIO_MODES[config[CONF_MODE]], config[CONF_INVERTED])
yield MCP23017GPIOPin.new(parent, config[CONF_NUMBER], config[CONF_MODE], config[CONF_INVERTED])

2
esphome/components/mhz19/mhz19.h
View File

@ -9,8 +9,6 @@ namespace mhz19 {
class MHZ19Component : public PollingComponent, public uart::UARTDevice {
public:
MHZ19Component(uint32_t update_interval) : PollingComponent(update_interval) {}
float get_setup_priority() const override;
void update() override;

18
esphome/components/mhz19/sensor.py
View File

@ -1,9 +1,8 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor, uart
from esphome.const import CONF_CO2, CONF_ID, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, \
ICON_PERIODIC_TABLE_CO2, UNIT_PARTS_PER_MILLION, UNIT_CELSIUS, \
ICON_THERMOMETER
from esphome.const import CONF_CO2, CONF_ID, CONF_TEMPERATURE, ICON_PERIODIC_TABLE_CO2, \
UNIT_PARTS_PER_MILLION, UNIT_CELSIUS, ICON_THERMOMETER
DEPENDENCIES = ['uart']
@ -11,17 +10,14 @@ mhz19_ns = cg.esphome_ns.namespace('mhz19')
MHZ19Component = mhz19_ns.class_('MHZ19Component', cg.PollingComponent, uart.UARTDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(MHZ19Component),
cv.Required(CONF_CO2): cv.nameable(
sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_PERIODIC_TABLE_CO2, 0)),
cv.Optional(CONF_TEMPERATURE): cv.nameable(
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 0)),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(uart.UART_DEVICE_SCHEMA)
cv.GenerateID(): cv.declare_id(MHZ19Component),
cv.Required(CONF_CO2): sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_PERIODIC_TABLE_CO2, 0),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 0),
}).extend(cv.polling_component_schema('60s')).extend(uart.UART_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield uart.register_uart_device(var, config)

14
esphome/components/monochromatic/light.py
View File

@ -6,13 +6,15 @@ from esphome.const import CONF_OUTPUT_ID, CONF_OUTPUT
monochromatic_ns = cg.esphome_ns.namespace('monochromatic')
MonochromaticLightOutput = monochromatic_ns.class_('MonochromaticLightOutput', light.LightOutput)
CONFIG_SCHEMA = cv.nameable(light.BRIGHTNESS_ONLY_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_variable_id(MonochromaticLightOutput),
cv.Required(CONF_OUTPUT): cv.use_variable_id(output.FloatOutput),
}))
CONFIG_SCHEMA = light.BRIGHTNESS_ONLY_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(MonochromaticLightOutput),
cv.Required(CONF_OUTPUT): cv.use_id(output.FloatOutput),
})
def to_code(config):
out = yield cg.get_variable(config[CONF_OUTPUT])
var = cg.new_Pvariable(config[CONF_OUTPUT_ID], out)
var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
yield light.register_light(var, config)
out = yield cg.get_variable(config[CONF_OUTPUT])
cg.add(var.set_output(out))

2
esphome/components/monochromatic/monochromatic_light_output.h
View File

@ -9,7 +9,7 @@ namespace monochromatic {
class MonochromaticLightOutput : public light::LightOutput {
public:
MonochromaticLightOutput(output::FloatOutput *output) : output_(output) {}
void set_output(output::FloatOutput *output) { output_ = output; }
light::LightTraits get_traits() override {
auto traits = light::LightTraits();
traits.set_supports_brightness(true);

2
esphome/components/mpr121/__init__.py
View File

@ -12,7 +12,7 @@ MPR121Component = mpr121_ns.class_('MPR121Component', cg.Component, i2c.I2CDevic
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(MPR121Component),
cv.GenerateID(): cv.declare_id(MPR121Component),
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x5A))

23
esphome/components/mpr121/binary_sensor.py
View File

@ -1,21 +1,24 @@
from esphome.components import binary_sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_CHANNEL, CONF_NAME, CONF_ID
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_CHANNEL, CONF_ID
from . import mpr121_ns, MPR121Component, CONF_MPR121_ID
DEPENDENCIES = ['mpr121']
MPR121Channel = mpr121_ns.class_('MPR121Channel', binary_sensor.BinarySensor)
CONFIG_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MPR121Channel),
cv.GenerateID(CONF_MPR121_ID): cv.use_variable_id(MPR121Component),
cv.Required(CONF_CHANNEL): cv.All(cv.int_, cv.Range(min=0, max=11))
}))
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(MPR121Channel),
cv.GenerateID(CONF_MPR121_ID): cv.use_id(MPR121Component),
cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=11),
})
def to_code(config):
hub = yield cg.get_variable(config[CONF_MPR121_ID])
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME], config[CONF_CHANNEL])
var = cg.new_Pvariable(config[CONF_ID])
yield binary_sensor.register_binary_sensor(var, config)
cg.add(var.set_channel(config[CONF_CHANNEL]))
hub = yield cg.get_variable(config[CONF_MPR121_ID])
cg.add(hub.register_channel(var))

4
esphome/components/mpr121/mpr121.h
View File

@ -47,11 +47,11 @@ enum {
class MPR121Channel : public binary_sensor::BinarySensor {
public:
MPR121Channel(const std::string &name, int channel) : BinarySensor(name), channel_(channel) {}
void set_channel(uint8_t channel) { channel_ = channel; }
void process(uint16_t data) { this->publish_state(static_cast<bool>(data & (1 << this->channel_))); }
protected:
int channel_{0};
uint8_t channel_{0};
};
class MPR121Component : public Component, public i2c::I2CDevice {

2
esphome/components/mpu6050/mpu6050.h
View File

@ -9,8 +9,6 @@ namespace mpu6050 {
class MPU6050Component : public PollingComponent, public i2c::I2CDevice {
public:
MPU6050Component(uint32_t update_interval) : PollingComponent(update_interval) {}
void setup() override;
void dump_config() override;

23
esphome/components/mpu6050/sensor.py
View File

@ -2,7 +2,7 @@ import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_ID, CONF_TEMPERATURE, \
CONF_UPDATE_INTERVAL, ICON_BRIEFCASE_DOWNLOAD, UNIT_METER_PER_SECOND_SQUARED, \
ICON_BRIEFCASE_DOWNLOAD, UNIT_METER_PER_SECOND_SQUARED, \
ICON_SCREEN_ROTATION, UNIT_DEGREE_PER_SECOND, ICON_THERMOMETER, UNIT_CELSIUS
DEPENDENCIES = ['i2c']
@ -22,20 +22,19 @@ gyro_schema = sensor.sensor_schema(UNIT_DEGREE_PER_SECOND, ICON_SCREEN_ROTATION,
temperature_schema = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(MPU6050Component),
cv.Optional(CONF_ACCEL_X): cv.nameable(accel_schema),
cv.Optional(CONF_ACCEL_Y): cv.nameable(accel_schema),
cv.Optional(CONF_ACCEL_Z): cv.nameable(accel_schema),
cv.Optional(CONF_GYRO_X): cv.nameable(gyro_schema),
cv.Optional(CONF_GYRO_Y): cv.nameable(gyro_schema),
cv.Optional(CONF_GYRO_Z): cv.nameable(gyro_schema),
cv.Optional(CONF_TEMPERATURE): cv.nameable(temperature_schema),
cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x68))
cv.GenerateID(): cv.declare_id(MPU6050Component),
cv.Optional(CONF_ACCEL_X): accel_schema,
cv.Optional(CONF_ACCEL_Y): accel_schema,
cv.Optional(CONF_ACCEL_Z): accel_schema,
cv.Optional(CONF_GYRO_X): gyro_schema,
cv.Optional(CONF_GYRO_Y): gyro_schema,
cv.Optional(CONF_GYRO_Z): gyro_schema,
cv.Optional(CONF_TEMPERATURE): temperature_schema,
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x68))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_UPDATE_INTERVAL])
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)

77
esphome/components/mqtt/__init__.py
View File

@ -1,10 +1,10 @@
import re
from esphome import automation
from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition
from esphome.components import logger
import esphome.config_validation as cv
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.automation import Condition
from esphome.components import logger
from esphome.const import CONF_AVAILABILITY, CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_CLIENT_ID, \
CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, \
CONF_ID, CONF_KEEPALIVE, CONF_LEVEL, CONF_LOG_TOPIC, CONF_ON_JSON_MESSAGE, CONF_ON_MESSAGE, \
@ -14,6 +14,7 @@ from esphome.const import CONF_AVAILABILITY, CONF_BIRTH_MESSAGE, CONF_BROKER, CO
CONF_WILL_MESSAGE
from esphome.core import coroutine_with_priority, coroutine, CORE
DEPENDENCIES = ['network']
AUTO_LOAD = ['json']
@ -37,11 +38,12 @@ MQTT_MESSAGE_SCHEMA = cv.Any(None, MQTT_MESSAGE_BASE.extend({
mqtt_ns = cg.esphome_ns.namespace('mqtt')
MQTTMessage = mqtt_ns.struct('MQTTMessage')
MQTTClientComponent = mqtt_ns.class_('MQTTClientComponent', cg.Component)
MQTTPublishAction = mqtt_ns.class_('MQTTPublishAction', cg.Action)
MQTTPublishJsonAction = mqtt_ns.class_('MQTTPublishJsonAction', cg.Action)
MQTTMessageTrigger = mqtt_ns.class_('MQTTMessageTrigger', cg.Trigger.template(cg.std_string))
MQTTPublishAction = mqtt_ns.class_('MQTTPublishAction', automation.Action)
MQTTPublishJsonAction = mqtt_ns.class_('MQTTPublishJsonAction', automation.Action)
MQTTMessageTrigger = mqtt_ns.class_('MQTTMessageTrigger',
automation.Trigger.template(cg.std_string))
MQTTJsonMessageTrigger = mqtt_ns.class_('MQTTJsonMessageTrigger',
cg.Trigger.template(cg.JsonObjectConstRef))
automation.Trigger.template(cg.JsonObjectConstRef))
MQTTComponent = mqtt_ns.class_('MQTTComponent', cg.Component)
MQTTConnectedCondition = mqtt_ns.class_('MQTTConnectedCondition', Condition)
@ -97,12 +99,12 @@ def validate_fingerprint(value):
CONFIG_SCHEMA = cv.All(cv.Schema({
cv.GenerateID(): cv.declare_variable_id(MQTTClientComponent),
cv.GenerateID(): cv.declare_id(MQTTClientComponent),
cv.Required(CONF_BROKER): cv.string_strict,
cv.Optional(CONF_PORT, default=1883): cv.port,
cv.Optional(CONF_USERNAME, default=''): cv.string,
cv.Optional(CONF_PASSWORD, default=''): cv.string,
cv.Optional(CONF_CLIENT_ID, default=lambda: CORE.name): cv.All(cv.string, cv.Length(max=23)),
cv.Optional(CONF_CLIENT_ID, default=lambda: CORE.name): cv.string,
cv.Optional(CONF_DISCOVERY, default=True): cv.Any(cv.boolean, cv.one_of("CLEAN", upper=True)),
cv.Optional(CONF_DISCOVERY_RETAIN, default=True): cv.boolean,
cv.Optional(CONF_DISCOVERY_PREFIX, default="homeassistant"): cv.publish_topic,
@ -120,13 +122,13 @@ CONFIG_SCHEMA = cv.All(cv.Schema({
cv.Optional(CONF_KEEPALIVE, default='15s'): cv.positive_time_period_seconds,
cv.Optional(CONF_REBOOT_TIMEOUT, default='5min'): cv.positive_time_period_milliseconds,
cv.Optional(CONF_ON_MESSAGE): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTMessageTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MQTTMessageTrigger),
cv.Required(CONF_TOPIC): cv.subscribe_topic,
cv.Optional(CONF_QOS, default=0): cv.mqtt_qos,
cv.Optional(CONF_PAYLOAD): cv.string_strict,
}),
cv.Optional(CONF_ON_JSON_MESSAGE): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTJsonMessageTrigger),
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MQTTJsonMessageTrigger),
cv.Required(CONF_TOPIC): cv.subscribe_topic,
cv.Optional(CONF_QOS, default=0): cv.mqtt_qos,
}),
@ -221,7 +223,7 @@ def to_code(config):
MQTT_PUBLISH_ACTION_SCHEMA = cv.Schema({
cv.GenerateID(): cv.use_variable_id(MQTTClientComponent),
cv.GenerateID(): cv.use_id(MQTTClientComponent),
cv.Required(CONF_TOPIC): cv.templatable(cv.publish_topic),
cv.Required(CONF_PAYLOAD): cv.templatable(cv.mqtt_payload),
cv.Optional(CONF_QOS, default=0): cv.templatable(cv.mqtt_qos),
@ -229,26 +231,24 @@ MQTT_PUBLISH_ACTION_SCHEMA = cv.Schema({
})
@ACTION_REGISTRY.register('mqtt.publish', MQTT_PUBLISH_ACTION_SCHEMA)
@automation.register_action('mqtt.publish', MQTTPublishAction, MQTT_PUBLISH_ACTION_SCHEMA)
def mqtt_publish_action_to_code(config, action_id, template_arg, args):
var = yield cg.get_variable(config[CONF_ID])