def validate_touch_pad(value):
value = gpio.validate_gpio_pin(value)
if value not in TOUCH_PADS:
raise cv.Invalid(f"Pin {value} does not support touch pads.")
return value
ESP32TouchBinarySensor = esp32_touch_ns.class_("ESP32TouchBinarySensor",
binary_sensor.BinarySensor)
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,
cv.Optional(CONF_WAKEUP_THRESHOLD, default=0):
cv.uint16_t,
})
async def to_code(config):
hub = await cg.get_variable(config[CONF_ESP32_TOUCH_ID])
var = cg.new_Pvariable(
config[CONF_ID],
TOUCH_PADS[config[CONF_PIN]],
config[CONF_THRESHOLD],
except ValueError:
raise cv.Invalid(
"Valid characters for parts of a UID are 0123456789ABCDEF.")
if x < 0 or x > 255:
raise cv.Invalid(
"Valid values for UID parts (separated by '-') are 00 to FF")
return value
PN532BinarySensor = pn532_ns.class_('PN532BinarySensor',
binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(PN532BinarySensor),
cv.GenerateID(CONF_PN532_ID):
cv.use_id(PN532),
cv.Required(CONF_UID):
validate_uid,
})
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield binary_sensor.register_binary_sensor(var, config)
hub = yield cg.get_variable(config[CONF_PN532_ID])
cg.add(hub.register_tag(var))
addr = [HexInt(int(x, 16)) for x in config[CONF_UID].split('-')]
cg.add(var.set_uid(addr))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import web_server_base
from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
from esphome.const import CONF_ID
from esphome.core import coroutine_with_priority
AUTO_LOAD = ["web_server_base"]
DEPENDENCIES = ["wifi"]
CODEOWNERS = ["@OttoWinter"]
captive_portal_ns = cg.esphome_ns.namespace("captive_portal")
CaptivePortal = captive_portal_ns.class_("CaptivePortal", cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(CaptivePortal),
cv.GenerateID(CONF_WEB_SERVER_BASE_ID):
cv.use_id(web_server_base.WebServerBase),
}).extend(cv.COMPONENT_SCHEMA)
@coroutine_with_priority(64.0)
def to_code(config):
paren = yield cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])
var = cg.new_Pvariable(config[CONF_ID], paren)
yield cg.register_component(var, config)
cg.add_define("USE_CAPTIVE_PORTAL")
def validate_mode(value):
if not (value[CONF_INPUT] or value[CONF_OUTPUT]):
raise cv.Invalid("Mode must be either input or output")
if value[CONF_INPUT] and value[CONF_OUTPUT]:
raise cv.Invalid("Mode must be either input or output")
if value[CONF_PULLUP] and not value[CONF_INPUT]:
raise cv.Invalid("Pullup only available with input")
return value
CONF_SX1509 = "sx1509"
SX1509_PIN_SCHEMA = cv.All({
cv.GenerateID():
cv.declare_id(SX1509GPIOPin),
cv.Required(CONF_SX1509):
cv.use_id(SX1509Component),
cv.Required(CONF_NUMBER):
cv.int_range(min=0, max=15),
cv.Optional(CONF_MODE, default={}):
cv.All(
{
cv.Optional(CONF_INPUT, default=False): cv.boolean,
cv.Optional(CONF_PULLUP, default=False): cv.boolean,
cv.Optional(CONF_OUTPUT, default=False): cv.boolean,
},
validate_mode,
),
cv.Optional(CONF_INVERTED, default=False):
cv.boolean,
})
async def register_sensor(var, config):
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_sensor(var))
await setup_sensor_core_(var, config)
async def new_sensor(config):
var = cg.new_Pvariable(config[CONF_ID])
await register_sensor(var, config)
return var
SENSOR_IN_RANGE_CONDITION_SCHEMA = cv.All(
{
cv.Required(CONF_ID): cv.use_id(Sensor),
cv.Optional(CONF_ABOVE): cv.float_,
cv.Optional(CONF_BELOW): cv.float_,
},
cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW),
)
@automation.register_condition("sensor.in_range", SensorInRangeCondition,
SENSOR_IN_RANGE_CONDITION_SCHEMA)
async def sensor_in_range_to_code(config, condition_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(condition_id, template_arg, paren)
if CONF_ABOVE in config:
cg.add(var.set_min(config[CONF_ABOVE]))
CONF_THRESHOLD,
)
analog_threshold_ns = cg.esphome_ns.namespace("analog_threshold")
AnalogThresholdBinarySensor = analog_threshold_ns.class_(
"AnalogThresholdBinarySensor", binary_sensor.BinarySensor, cg.Component
)
CONF_UPPER = "upper"
CONF_LOWER = "lower"
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(AnalogThresholdBinarySensor),
cv.Required(CONF_SENSOR_ID): cv.use_id(sensor.Sensor),
cv.Required(CONF_THRESHOLD): cv.Any(
cv.float_,
cv.Schema(
{cv.Required(CONF_UPPER): cv.float_, cv.Required(CONF_LOWER): cv.float_}
),
),
}
).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
var = await binary_sensor.new_binary_sensor(config)
await cg.register_component(var, config)
sens = await cg.get_variable(config[CONF_SENSOR_ID])
CONF_GROUP,
)
DEPENDENCIES = ["binary_sensor"]
binary_sensor_map_ns = cg.esphome_ns.namespace("binary_sensor_map")
BinarySensorMap = binary_sensor_map_ns.class_("BinarySensorMap", cg.Component,
sensor.Sensor)
SensorMapType = binary_sensor_map_ns.enum("SensorMapType")
SENSOR_MAP_TYPES = {
CONF_GROUP: SensorMapType.BINARY_SENSOR_MAP_TYPE_GROUP,
}
entry = {
cv.Required(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_VALUE): cv.float_,
}
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_GROUP:
sensor.sensor_schema(
BinarySensorMap,
icon=ICON_CHECK_CIRCLE_OUTLINE,
accuracy_decimals=0,
).extend({
cv.Required(CONF_CHANNELS):
cv.All(cv.ensure_list(entry), cv.Length(min=1)),
}),
},
cg.add(var.set_has_tilt(True))
if CONF_TILT_LAMBDA in config:
tilt_template_ = yield cg.process_lambda(
config[CONF_TILT_LAMBDA], [],
return_type=cg.optional.template(float))
cg.add(var.set_tilt_lambda(tilt_template_))
cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
cg.add(var.set_assumed_state(config[CONF_ASSUMED_STATE]))
cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
@automation.register_action('cover.template.publish', cover.CoverPublishAction,
cv.Schema({
cv.Required(CONF_ID):
cv.use_id(cover.Cover),
cv.Exclusive(CONF_STATE, 'pos'):
cv.templatable(cover.validate_cover_state),
cv.Exclusive(CONF_POSITION, 'pos'):
cv.templatable(cv.zero_to_one_float),
cv.Optional(CONF_CURRENT_OPERATION):
cv.templatable(cover.validate_cover_operation),
cv.Optional(CONF_TILT):
cv.templatable(cv.zero_to_one_float),
}))
def cover_template_publish_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)
if CONF_STATE in config:
template_ = yield cg.templatable(config[CONF_STATE], args, float)
cg.add(var.set_position(template_))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import output
from esphome.const import CONF_CHANNEL, CONF_ID
from . import PCA9685Output, pca9685_ns
DEPENDENCIES = ['arduino_pe']
PCA9685Channel = pca9685_ns.class_('ArduinoPEOutputChannel', output.Output)
CONF_ARDUINO_PE_ID = 'arduino_pe_id'
CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
cv.Required(CONF_ID):
cv.declare_id(PCA9685Channel),
cv.GenerateID(CONF_PCA9685_ID):
cv.use_id(PCA9685Output),
cv.Required(CONF_CHANNEL):
cv.int_range(min=0, max=15),
})
def to_code(config):
paren = yield cg.get_variable(config[CONF_PCA9685_ID])
rhs = paren.create_channel(config[CONF_CHANNEL])
var = cg.Pvariable(config[CONF_ID], rhs)
yield output.register_output(var, config)
remote_base,
)
from esphome.components.remote_base import CONF_RECEIVER_ID, CONF_TRANSMITTER_ID
from esphome.const import CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT, CONF_SENSOR
from esphome.core import coroutine
AUTO_LOAD = ["sensor", "remote_base"]
CODEOWNERS = ["@glmnet"]
climate_ir_ns = cg.esphome_ns.namespace("climate_ir")
ClimateIR = climate_ir_ns.class_("ClimateIR", climate.Climate, cg.Component,
remote_base.RemoteReceiverListener)
CLIMATE_IR_SCHEMA = climate.CLIMATE_SCHEMA.extend({
cv.GenerateID(CONF_TRANSMITTER_ID):
cv.use_id(remote_transmitter.RemoteTransmitterComponent),
cv.Optional(CONF_SUPPORTS_COOL, default=True):
cv.boolean,
cv.Optional(CONF_SUPPORTS_HEAT, default=True):
cv.boolean,
cv.Optional(CONF_SENSOR):
cv.use_id(sensor.Sensor),
}).extend(cv.COMPONENT_SCHEMA)
CLIMATE_IR_WITH_RECEIVER_SCHEMA = CLIMATE_IR_SCHEMA.extend({
cv.Optional(CONF_RECEIVER_ID):
cv.use_id(remote_receiver.RemoteReceiverComponent),
})
@coroutine
"VERTICAL": DirectionType.DIRECTION_TYPE_VERTICAL,
}
ValuePositionType = graph_ns.enum("ValuePositionType")
VALUE_POSITION_TYPE = {
"NONE": ValuePositionType.VALUE_POSITION_TYPE_NONE,
"AUTO": ValuePositionType.VALUE_POSITION_TYPE_AUTO,
"BESIDE": ValuePositionType.VALUE_POSITION_TYPE_BESIDE,
"BELOW": ValuePositionType.VALUE_POSITION_TYPE_BELOW,
}
GRAPH_TRACE_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(GraphTrace),
cv.Required(CONF_SENSOR):
cv.use_id(sensor.Sensor),
cv.Optional(CONF_NAME):
cv.string,
cv.Optional(CONF_LINE_THICKNESS):
cv.positive_int,
cv.Optional(CONF_LINE_TYPE):
cv.enum(LINE_TYPE, upper=True),
cv.Optional(CONF_COLOR):
cv.use_id(color.ColorStruct),
})
GRAPH_LEGEND_SCHEMA = cv.Schema({
cv.GenerateID(CONF_ID):
cv.declare_id(GraphLegend),
cv.Required(CONF_NAME_FONT):
cv.use_id(Font),
raise cv.Invalid(
"Valid characters for parts of a UID are 0123456789ABCDEF."
) from err
if x < 0 or x > 255:
raise cv.Invalid(
"Valid values for UID parts (separated by '-') are 00 to FF"
)
return value
RC522BinarySensor = rc522_ns.class_("RC522BinarySensor", binary_sensor.BinarySensor)
CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(RC522BinarySensor),
cv.GenerateID(CONF_RC522_ID): cv.use_id(RC522),
cv.Required(CONF_UID): validate_uid,
}
)
@coroutine
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield binary_sensor.register_binary_sensor(var, config)
hub = yield cg.get_variable(config[CONF_RC522_ID])
cg.add(hub.register_tag(var))
addr = [HexInt(int(x, 16)) for x in config[CONF_UID].split("-")]
cg.add(var.set_uid(addr))
cv.Optional(CONF_FREQUENCY, default="1kHz"):
validate_frequency,
}).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await output.register_output(var, config)
pin = await 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),
}),
)
async def esp8266_set_frequency_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
template_ = await cg.templatable(config[CONF_FREQUENCY], args, float)
cg.add(var.set_frequency(template_))
return var
if not CORE.has_id(config[CONF_ID]):
var = cg.Pvariable(config[CONF_ID], var)
cg.add(cg.App.register_binary_sensor(var))
yield setup_binary_sensor_core_(var, config)
@coroutine
def new_binary_sensor(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
yield register_binary_sensor(var, config)
yield var
BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(BinarySensor),
cv.Optional(CONF_FOR):
cv.invalid("This option has been removed in 1.13, please use the "
"'for' condition instead."),
})
@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):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(condition_id, template_arg, paren, True)
@automation.register_condition('binary_sensor.is_off', BinarySensorCondition,
BINARY_SENSOR_CONDITION_SCHEMA)
ICON_TEST_TUBE = "mdi:test-tube"
TYPES = {
CONF_TEMPERATURE: "set_temperature_sensor",
CONF_PRESSURE: "set_pressure_sensor",
CONF_HUMIDITY: "set_humidity_sensor",
CONF_GAS_RESISTANCE: "set_gas_resistance_sensor",
CONF_IAQ: "set_iaq_sensor",
CONF_IAQ_ACCURACY: "set_iaq_accuracy_sensor",
CONF_CO2_EQUIVALENT: "set_co2_equivalent_sensor",
CONF_BREATH_VOC_EQUIVALENT: "set_breath_voc_equivalent_sensor",
}
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_BME680_BSEC_ID):
cv.use_id(BME680BSECComponent),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1,
DEVICE_CLASS_TEMPERATURE),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1,
DEVICE_CLASS_PRESSURE),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1,
DEVICE_CLASS_HUMIDITY),
cv.Optional(CONF_GAS_RESISTANCE):
sensor.sensor_schema(UNIT_OHM, ICON_GAS_CYLINDER, 0, DEVICE_CLASS_EMPTY),
cv.Optional(CONF_IAQ):
sensor.sensor_schema(UNIT_IAQ, ICON_GAUGE, 0, DEVICE_CLASS_EMPTY),
cv.Optional(CONF_IAQ_ACCURACY):
sensor.sensor_schema(UNIT_EMPTY, ICON_ACCURACY, 0, DEVICE_CLASS_EMPTY),
ICON_EMPTY,
UNIT_CELSIUS,
CONF_ID,
)
from . import DallasComponent, dallas_ns
DallasTemperatureSensor = dallas_ns.class_("DallasTemperatureSensor",
sensor.Sensor)
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1,
DEVICE_CLASS_TEMPERATURE).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.int_range(min=9, max=12),
}),
cv.has_exactly_one_key(CONF_ADDRESS, CONF_INDEX),
)
async def to_code(config):
hub = await cg.get_variable(config[CONF_DALLAS_ID])
if CONF_ADDRESS in config:
address = config[CONF_ADDRESS]
import esphome.config_validation as cv
from esphome.components import sensor, time
from esphome.const import CONF_ID, CONF_TIME_ID
DEPENDENCIES = ["time"]
CONF_POWER_ID = "power_id"
total_daily_energy_ns = cg.esphome_ns.namespace("total_daily_energy")
TotalDailyEnergy = total_daily_energy_ns.class_("TotalDailyEnergy",
sensor.Sensor, cg.Component)
CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(TotalDailyEnergy),
cv.GenerateID(CONF_TIME_ID):
cv.use_id(time.RealTimeClock),
cv.Required(CONF_POWER_ID):
cv.use_id(sensor.Sensor),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
sens = yield cg.get_variable(config[CONF_POWER_ID])
cg.add(var.set_parent(sens))
time_ = yield cg.get_variable(config[CONF_TIME_ID])
cg.add(var.set_time(time_))
def declare_protocol(name):
data = ns.struct('{}Data'.format(name))
binary_sensor_ = ns.class_('{}BinarySensor'.format(name),
RemoteReceiverBinarySensorBase)
trigger = ns.class_('{}Trigger'.format(name), RemoteReceiverTrigger)
action = ns.class_('{}Action'.format(name), RemoteTransmitterActionBase)
dumper = ns.class_('{}Dumper'.format(name), RemoteTransmitterDumper)
return data, binary_sensor_, trigger, action, dumper
BINARY_SENSOR_REGISTRY = Registry(
binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(CONF_RECEIVER_ID):
cv.use_id(RemoteReceiverBase),
}))
validate_binary_sensor = cv.validate_registry_entry('remote receiver',
BINARY_SENSOR_REGISTRY)
TRIGGER_REGISTRY = SimpleRegistry()
DUMPER_REGISTRY = Registry({
cv.GenerateID(CONF_RECEIVER_ID):
cv.use_id(RemoteReceiverBase),
})
def validate_dumpers(value):
if isinstance(value, string_types) and value.lower() == 'all':
return validate_dumpers(list(DUMPER_REGISTRY.keys()))
return cv.validate_registry('dumper', DUMPER_REGISTRY)(value)
CONF_SECURITY_LEVEL,
CONF_STATUS,
ENTITY_CATEGORY_DIAGNOSTIC,
ICON_ACCOUNT,
ICON_ACCOUNT_CHECK,
ICON_DATABASE,
ICON_FINGERPRINT,
ICON_SECURITY,
)
from . import CONF_FINGERPRINT_GROW_ID, FingerprintGrowComponent
DEPENDENCIES = ["fingerprint_grow"]
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_FINGERPRINT_GROW_ID):
cv.use_id(FingerprintGrowComponent),
cv.Optional(CONF_FINGERPRINT_COUNT):
sensor.sensor_schema(
icon=ICON_FINGERPRINT,
accuracy_decimals=0,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
cv.Optional(CONF_STATUS):
sensor.sensor_schema(
accuracy_decimals=0,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
cv.Optional(CONF_CAPACITY):
sensor.sensor_schema(
icon=ICON_DATABASE,
accuracy_decimals=0,
CONF_ENTITY_CATEGORY,
CONF_ICON,
CONF_ID,
CONF_SOURCE_ID,
)
from esphome.core.entity_helpers import inherit_property_from
from .. import copy_ns
CopyFan = copy_ns.class_("CopyFan", fan.Fan, cg.Component)
CONFIG_SCHEMA = fan.FAN_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(CopyFan),
cv.Required(CONF_SOURCE_ID):
cv.use_id(fan.Fan),
}).extend(cv.COMPONENT_SCHEMA)
FINAL_VALIDATE_SCHEMA = cv.All(
inherit_property_from(CONF_ICON, CONF_SOURCE_ID),
inherit_property_from(CONF_ENTITY_CATEGORY, CONF_SOURCE_ID),
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await fan.register_fan(var, config)
await cg.register_component(var, config)
source = await cg.get_variable(config[CONF_SOURCE_ID])
cg.add(var.set_source(source))
validate_swing_modes = cv.enum(ALLOWED_CLIMATE_SWING_MODES, upper=True)
validate_custom_fan_modes = cv.enum(CUSTOM_FAN_MODES, upper=True)
validate_custom_presets = cv.enum(CUSTOM_PRESETS, upper=True)
CONFIG_SCHEMA = cv.All(
climate.CLIMATE_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(AirConditioner),
cv.Optional(CONF_PERIOD, default="1s"):
cv.time_period,
cv.Optional(CONF_TIMEOUT, default="2s"):
cv.time_period,
cv.Optional(CONF_NUM_ATTEMPTS, default=3):
cv.int_range(min=1, max=5),
cv.OnlyWith(CONF_TRANSMITTER_ID, "remote_transmitter"):
cv.use_id(remote_transmitter.RemoteTransmitterComponent),
cv.Optional(CONF_BEEPER, default=False):
cv.boolean,
cv.Optional(CONF_AUTOCONF, default=True):
cv.boolean,
cv.Optional(CONF_SUPPORTED_MODES):
cv.ensure_list(validate_modes),
cv.Optional(CONF_SUPPORTED_SWING_MODES):
cv.ensure_list(validate_swing_modes),
cv.Optional(CONF_SUPPORTED_PRESETS):
cv.ensure_list(validate_presets),
cv.Optional(CONF_CUSTOM_PRESETS):
cv.ensure_list(validate_custom_presets),
cv.Optional(CONF_CUSTOM_FAN_MODES):
cv.ensure_list(validate_custom_fan_modes),
cv.Optional(CONF_OUTDOOR_TEMPERATURE):
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import output
from esphome.const import CONF_CHANNEL, CONF_ID
from . import SM16716
DEPENDENCIES = ['sm16716']
Channel = SM16716.class_('Channel', output.FloatOutput)
CONF_SM16716_ID = 'sm16716_id'
CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
cv.GenerateID(CONF_SM16716_ID):
cv.use_id(SM16716),
cv.Required(CONF_ID):
cv.declare_id(Channel),
cv.Required(CONF_CHANNEL):
cv.int_range(min=0, max=65535),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield output.register_output(var, config)
parent = yield cg.get_variable(config[CONF_SM16716_ID])
cg.add(var.set_parent(parent))
cg.add(var.set_channel(config[CONF_CHANNEL]))
def validate_repeat(value):
if isinstance(value, dict):
return cv.Schema({
cv.Required(CONF_TIMES):
cv.templatable(cv.positive_int),
cv.Optional(CONF_WAIT_TIME, default="25ms"):
cv.templatable(cv.positive_time_period_microseconds),
})(value)
return validate_repeat({CONF_TIMES: value})
BASE_REMOTE_TRANSMITTER_SCHEMA = cv.Schema({
cv.GenerateID(CONF_TRANSMITTER_ID):
cv.use_id(RemoteTransmitterBase),
cv.Optional(CONF_REPEAT):
validate_repeat,
})
def register_action(name, type_, schema):
validator = templatize(schema).extend(BASE_REMOTE_TRANSMITTER_SCHEMA)
registerer = automation.register_action(
f"remote_transmitter.transmit_{name}", type_, validator)
def decorator(func):
async def new_func(config, action_id, template_arg, args):
transmitter = await cg.get_variable(config[CONF_TRANSMITTER_ID])
var = cg.new_Pvariable(action_id, template_arg)
cg.add(var.set_parent(transmitter))
})
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(var.set_method(METHODS[config[CONF_METHOD]]))
@register_addressable_effect(
"e131",
E131AddressableLightEffect,
"E1.31",
{
cv.GenerateID(CONF_E131_ID):
cv.use_id(E131Component),
cv.Required(CONF_UNIVERSE):
cv.int_range(min=1, max=512),
cv.Optional(CONF_CHANNELS, default="RGB"):
cv.one_of(*CHANNELS, upper=True),
},
)
def e131_light_effect_to_code(config, effect_id):
parent = yield cg.get_variable(config[CONF_E131_ID])
effect = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(effect.set_first_universe(config[CONF_UNIVERSE]))
cg.add(effect.set_channels(CHANNELS[config[CONF_CHANNELS]]))
cg.add(effect.set_e131(parent))
yield effect
await uart.register_uart_device(var, config)
if CONF_CO2 in config:
sens = await sensor.new_sensor(config[CONF_CO2])
cg.add(var.set_co2_sensor(sens))
if CONF_TEMPERATURE in config:
sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
cg.add(var.set_temperature_sensor(sens))
if CONF_AUTOMATIC_BASELINE_CALIBRATION in config:
cg.add(var.set_abc_enabled(
config[CONF_AUTOMATIC_BASELINE_CALIBRATION]))
CALIBRATION_ACTION_SCHEMA = maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(MHZ19Component),
})
@automation.register_action("mhz19.calibrate_zero", MHZ19CalibrateZeroAction,
CALIBRATION_ACTION_SCHEMA)
@automation.register_action("mhz19.abc_enable", MHZ19ABCEnableAction,
CALIBRATION_ACTION_SCHEMA)
@automation.register_action("mhz19.abc_disable", MHZ19ABCDisableAction,
CALIBRATION_ACTION_SCHEMA)
async def mhz19_calibration_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
cv.frequency,
cv.Optional(CONF_CHANNEL):
cv.int_range(min=0, max=15),
}).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
gpio = await cg.gpio_pin_expression(config[CONF_PIN])
var = cg.new_Pvariable(config[CONF_ID], gpio)
await cg.register_component(var, config)
await output.register_output(var, config)
if CONF_CHANNEL in config:
cg.add(var.set_channel(config[CONF_CHANNEL]))
cg.add(var.set_frequency(config[CONF_FREQUENCY]))
@automation.register_action(
"output.ledc.set_frequency",
SetFrequencyAction,
cv.Schema({
cv.Required(CONF_ID): cv.use_id(LEDCOutput),
cv.Required(CONF_FREQUENCY): cv.templatable(validate_frequency),
}),
)
async def ledc_set_frequency_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
template_ = await cg.templatable(config[CONF_FREQUENCY], args, float)
cg.add(var.set_frequency(template_))
return var
CODEOWNERS = ["@dentra"]
CONF_APPARENT_POWER = "apparent_power"
CONF_REACTIVE_POWER = "reactive_power"
CONF_WAIT_TIME = "wait_time"
UNIT_POWER_FACTOR = "Cos φ"
energy_monitoring_ns = cg.esphome_ns.namespace("energy_monitoring")
EnergyMonitoring = energy_monitoring_ns.class_("EnergyMonitoring", cg.Component)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(EnergyMonitoring),
cv.GenerateID(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
cv.Required(CONF_POWER): cv.use_id(sensor.Sensor),
cv.Required(CONF_VOLTAGE): cv.use_id(sensor.Sensor),
cv.Optional(CONF_CURRENT): cv.use_id(sensor.Sensor),
cv.Optional(CONF_APPARENT_POWER): sensor.sensor_schema(
UNIT_VOLT_AMPS, ICON_FLASH, 1, DEVICE_CLASS_EMPTY
),
cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(
UNIT_VOLT_AMPS_REACTIVE, ICON_FLASH, 1, DEVICE_CLASS_EMPTY
),
cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(
UNIT_POWER_FACTOR, ICON_FLASH, 2, DEVICE_CLASS_POWER_FACTOR
),
cv.Optional(CONF_WAIT_TIME, default=500): cv.uint32_t,
}
).extend(cv.COMPONENT_SCHEMA)
AUTO_LOAD = ["voltage_sampler"]
DEPENDENCIES = ["mcp3008"]
MCP3008Sensor = mcp3008_ns.class_("MCP3008Sensor", sensor.Sensor,
cg.PollingComponent,
voltage_sampler.VoltageSampler)
CONF_REFERENCE_VOLTAGE = "reference_voltage"
CONF_MCP3008_ID = "mcp3008_id"
CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(MCP3008Sensor),
cv.GenerateID(CONF_MCP3008_ID):
cv.use_id(MCP3008),
cv.Required(CONF_NUMBER):
cv.int_,
cv.Optional(CONF_REFERENCE_VOLTAGE, default="3.3V"):
cv.voltage,
}).extend(cv.polling_component_schema("1s"))
def to_code(config):
parent = yield cg.get_variable(config[CONF_MCP3008_ID])
var = cg.new_Pvariable(
config[CONF_ID],
parent,
config[CONF_NAME],
config[CONF_NUMBER],
config[CONF_REFERENCE_VOLTAGE],
if isinstance(value, str):
try:
value = ELEVATION_MAP[cv.one_of(*ELEVATION_MAP,
lower=True,
space='_')(value)]
except cv.Invalid:
pass
value = cv.angle(value)
return cv.float_range(min=-180, max=180)(value)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(Sun),
cv.GenerateID(CONF_TIME_ID):
cv.use_id(time.RealTimeClock),
cv.Required(CONF_LATITUDE):
cv.float_range(min=-90, max=90),
cv.Required(CONF_LONGITUDE):
cv.float_range(min=-180, max=180),
cv.Optional(CONF_ON_SUNRISE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(SunTrigger),
cv.Optional(CONF_ELEVATION, default=DEFAULT_ELEVATION):
elevation,
}),
cv.Optional(CONF_ON_SUNSET):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(SunTrigger),
def validate_optional_icon(config):
if CONF_ICON not in config:
config = config.copy()
config[CONF_ICON] = {
"sunset": ICON_WEATHER_SUNSET_DOWN,
"sunrise": ICON_WEATHER_SUNSET_UP,
}[config[CONF_TYPE]]
return config
CONFIG_SCHEMA = cv.All(
text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(SunTextSensor),
cv.GenerateID(CONF_SUN_ID):
cv.use_id(Sun),
cv.Required(CONF_TYPE):
cv.one_of(*SUN_TYPES, lower=True),
cv.Optional(CONF_ELEVATION, default=DEFAULT_ELEVATION):
elevation,
cv.Optional(CONF_FORMAT, default="%X"):
cv.string_strict,
}).extend(cv.polling_component_schema("60s")),
validate_optional_icon,
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await text_sensor.register_text_sensor(var, config)
