def validate_cron_keys(value):
if CONF_CRON in value:
for key in value.keys():
if key in CRON_KEYS:
raise vol.Invalid(
"Cannot use option {} when cron: is specified.".format(
key))
cron_ = value[CONF_CRON]
value = {x: value[x] for x in value if x != CONF_CRON}
value.update(cron_)
return value
return cv.has_at_least_one_key(*CRON_KEYS)(value)
vol.Optional(CONF_ACCEL_Y):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_ACCEL_Z):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_GYRO_X):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_GYRO_Y):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_GYRO_Z):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_TEMPERATURE):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.positive_time_period_milliseconds,
}),
cv.has_at_least_one_key(CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z,
CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z))
MPU6050Component = sensor.sensor_ns.MPU6050Component
MPU6050AccelSensor = sensor.sensor_ns.MPU6050AccelSensor
MPU6050GyroSensor = sensor.sensor_ns.MPU6050GyroSensor
MPU6050TemperatureSensor = sensor.sensor_ns.MPU6050TemperatureSensor
def to_code(config):
rhs = App.make_mpu6050_sensor(config[CONF_ADDRESS],
config.get(CONF_UPDATE_INTERVAL))
mpu = Pvariable(MPU6050Component, config[CONF_MAKE_ID], rhs)
if CONF_ACCEL_X in config:
conf = config[CONF_ACCEL_X]
rhs = mpu.Pmake_accel_x_sensor(conf[CONF_NAME])
sensor_ = Pvariable(MPU6050AccelSensor, conf[CONF_MQTT_ID], rhs)
from esphomeyaml.cpp_generator import variable, process_lambda, add
from esphomeyaml.cpp_helpers import setup_component
from esphomeyaml.cpp_types import Application, App, optional, NoArg
MakeTemplateCover = Application.struct('MakeTemplateCover')
TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover)
PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateCover),
cv.GenerateID(): cv.declare_variable_id(TemplateCover),
vol.Optional(CONF_LAMBDA): cv.lambda_,
vol.Optional(CONF_OPTIMISTIC): cv.boolean,
vol.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
vol.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
vol.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
def to_code(config):
rhs = App.make_template_cover(config[CONF_NAME])
make = variable(config[CONF_MAKE_ID], rhs)
cover.setup_cover(make.Ptemplate_, make.Pmqtt, config)
setup_component(make.Ptemplate_, config)
if CONF_LAMBDA in config:
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=optional.template(cover.CoverState)):
yield
add(make.Ptemplate_.set_state_lambda(template_))
if CONF_OPEN_ACTION in config:
cv.declare_variable_id(BME680GasResistanceSensor),
})),
vol.Optional(CONF_IIR_FILTER):
cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
vol.Optional(CONF_HEATER):
vol.Any(
None,
vol.All(
vol.Schema(
{
vol.Optional(CONF_TEMPERATURE, default=320):
vol.All(vol.Coerce(int), vol.Range(200, 400)),
vol.Optional(CONF_DURATION, default='150ms'):
vol.All(cv.positive_time_period_milliseconds,
vol.Range(max=core.TimePeriod(milliseconds=4032)))
}, cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION)))),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_bme680_sensor(config[CONF_TEMPERATURE][CONF_NAME],
config[CONF_PRESSURE][CONF_NAME],
config[CONF_HUMIDITY][CONF_NAME],
config[CONF_GAS_RESISTANCE][CONF_NAME],
config[CONF_ADDRESS],
config.get(CONF_UPDATE_INTERVAL))
make = variable(config[CONF_MAKE_ID], rhs)
bme680 = make.Pbme680
if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
vol.Optional(CONF_POWER):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(INA219PowerSensor),
})),
vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1):
vol.All(cv.resistance, vol.Range(min=0.0, max=32.0)),
vol.Optional(CONF_MAX_VOLTAGE, default=32.0):
vol.All(cv.voltage, vol.Range(min=0.0, max=32.0)),
vol.Optional(CONF_MAX_CURRENT, default=3.2):
vol.All(cv.current, vol.Range(min=0.0)),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema),
cv.has_at_least_one_key(*SENSOR_KEYS))
def to_code(config):
rhs = App.make_ina219(config[CONF_SHUNT_RESISTANCE],
config[CONF_MAX_CURRENT],
config[CONF_MAX_VOLTAGE], config[CONF_ADDRESS],
config.get(CONF_UPDATE_INTERVAL))
ina = Pvariable(config[CONF_ID], rhs)
if CONF_BUS_VOLTAGE in config:
conf = config[CONF_BUS_VOLTAGE]
sensor.register_sensor(ina.Pmake_bus_voltage_sensor(conf[CONF_NAME]),
conf)
if CONF_SHUNT_VOLTAGE in config:
conf = config[CONF_SHUNT_VOLTAGE]
sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(conf[CONF_NAME]),
sensor.EmptySensor)
PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766Component),
cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
vol.Optional(CONF_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766VoltageSensor),
})),
vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766CurrentSensor),
})),
vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766PowerSensor),
})),
}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
CONF_POWER))
def to_code(config):
for uart_ in get_variable(config[CONF_UART_ID]):
yield
rhs = App.make_cse7766(uart_)
cse = Pvariable(config[CONF_ID], rhs)
if CONF_VOLTAGE in config:
conf = config[CONF_VOLTAGE]
sensor.register_sensor(cse.make_voltage_sensor(conf[CONF_NAME]), conf)
if CONF_CURRENT in config:
conf = config[CONF_CURRENT]
sensor.register_sensor(cse.make_current_sensor(conf[CONF_NAME]), conf)
import esphomeyaml.config_validation as cv
from esphomeyaml import pins
from esphomeyaml.const import CONF_CLK_PIN, CONF_ID, CONF_MISO_PIN, CONF_MOSI_PIN
from esphomeyaml.helpers import App, Pvariable, esphomelib_ns, gpio_input_pin_expression, \
gpio_output_pin_expression, add
SPIComponent = esphomelib_ns.SPIComponent
SPI_SCHEMA = vol.All(
vol.Schema({
cv.GenerateID(): cv.declare_variable_id(SPIComponent),
vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
vol.Optional(CONF_MISO_PIN): pins.gpio_input_pin_schema,
vol.Optional(CONF_MOSI_PIN): pins.gpio_output_pin_schema,
}), cv.has_at_least_one_key(CONF_MISO_PIN, CONF_MOSI_PIN))
CONFIG_SCHEMA = vol.All(cv.ensure_list, [SPI_SCHEMA])
def to_code(config):
for conf in config:
clk = None
for clk in gpio_output_pin_expression(conf[CONF_CLK_PIN]):
yield
rhs = App.init_spi(clk)
spi = Pvariable(conf[CONF_ID], rhs)
if CONF_MISO_PIN in conf:
for miso in gpio_input_pin_expression(conf[CONF_MISO_PIN]):
yield
add(spi.set_miso(miso))
maybe_simple_id({
vol.Required(CONF_ID):
cv.use_variable_id(deep_sleep.DeepSleepComponent),
}),
vol.Optional(CONF_DEEP_SLEEP_PREVENT):
maybe_simple_id({
vol.Required(CONF_ID):
cv.use_variable_id(deep_sleep.DeepSleepComponent),
}),
vol.Optional(CONF_IF):
vol.All(
{
vol.Required(CONF_CONDITION): validate_recursive_condition,
vol.Optional(CONF_THEN): validate_recursive_action,
vol.Optional(CONF_ELSE): validate_recursive_action,
}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE)),
vol.Optional(CONF_LAMBDA):
cv.lambda_,
}, cv.has_exactly_one_key(*ACTION_KEYS))
])
# pylint: disable=invalid-name
DelayAction = esphomelib_ns.DelayAction
LambdaAction = esphomelib_ns.LambdaAction
IfAction = esphomelib_ns.IfAction
Automation = esphomelib_ns.Automation
CONDITIONS_SCHEMA = vol.All(cv.ensure_list, [
cv.templatable({
cv.GenerateID(CONF_CONDITION_ID):
cv.declare_variable_id(None),
cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
})),
vol.Optional(CONF_GYRO_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
})),
vol.Optional(CONF_GYRO_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
})),
vol.Optional(CONF_GYRO_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
})),
vol.Optional(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MPU6050TemperatureSensor),
})),
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
def to_code(config):
rhs = App.make_mpu6050_sensor(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
mpu = Pvariable(config[CONF_ID], rhs)
if CONF_ACCEL_X in config:
conf = config[CONF_ACCEL_X]
rhs = mpu.Pmake_accel_x_sensor(conf[CONF_NAME])
sensor.register_sensor(rhs, conf)
if CONF_ACCEL_Y in config:
conf = config[CONF_ACCEL_Y]
rhs = mpu.Pmake_accel_y_sensor(conf[CONF_NAME])
sensor.register_sensor(rhs, conf)
if CONF_ACCEL_Z in config:
conf = config[CONF_ACCEL_Z]
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_CLEAR_CHANNEL):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_ILLUMINANCE):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_COLOR_TEMPERATURE):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_INTEGRATION_TIME):
cv.one_of(*TCS34725_INTEGRATION_TIMES),
vol.Optional(CONF_GAIN):
vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS)),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}),
cv.has_at_least_one_key(CONF_RED_CHANNEL, CONF_GREEN_CHANNEL,
CONF_BLUE_CHANNEL, CONF_CLEAR_CHANNEL,
CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE))
def to_code(config):
rhs = App.make_tcs34725(config.get(CONF_UPDATE_INTERVAL))
tcs = Pvariable(config[CONF_ID], rhs)
if CONF_ADDRESS in config:
add(tcs.set_address(config[CONF_ADDRESS]))
if CONF_INTEGRATION_TIME in config:
add(
tcs.set_integration_time(
TCS34725_INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
if CONF_GAIN in config:
add(tcs.set_gain(TCS34725_GAINS[config[CONF_GAIN]]))
if CONF_RED_CHANNEL in config:
vol.Optional(CONF_STATE, default=True):
cv.boolean,
vol.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
vol.Optional(CONF_RED, default=1.0):
cv.percentage,
vol.Optional(CONF_GREEN, default=1.0):
cv.percentage,
vol.Optional(CONF_BLUE, default=1.0):
cv.percentage,
vol.Optional(CONF_WHITE, default=1.0):
cv.percentage,
vol.Required(CONF_DURATION):
cv.positive_time_period_milliseconds,
}),
cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED,
CONF_GREEN, CONF_BLUE, CONF_WHITE))
], vol.Length(min=2)),
}),
vol.Optional(CONF_FLICKER):
vol.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(FlickerLightEffect),
vol.Optional(CONF_NAME, default="Flicker"):
cv.string,
vol.Optional(CONF_ALPHA):
cv.percentage,
vol.Optional(CONF_INTENSITY):
cv.percentage,
}),
vol.Optional(CONF_FASTLED_LAMBDA):
vol.Schema({
value = cv.string(value)
if value.endswith(u'µT') or value.endswith('uT'):
value = value[:-2]
return cv.one_of(*HMC5883L_RANGES)(int(value))
PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(HMC5883LComponent),
vol.Optional(CONF_ADDRESS): cv.i2c_address,
vol.Optional(CONF_FIELD_STRENGTH_X): cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_FIELD_STRENGTH_Y): cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_FIELD_STRENGTH_Z): cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_HEADING): cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
vol.Optional(CONF_RANGE): validate_range,
}), cv.has_at_least_one_key(CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z,
CONF_HEADING))
def to_code(config):
rhs = App.make_hmc5883l(config.get(CONF_UPDATE_INTERVAL))
hmc = Pvariable(config[CONF_ID], rhs)
if CONF_ADDRESS in config:
add(hmc.set_address(config[CONF_ADDRESS]))
if CONF_RANGE in config:
add(hmc.set_range(HMC5883L_RANGES[config[CONF_RANGE]]))
if CONF_FIELD_STRENGTH_X in config:
conf = config[CONF_FIELD_STRENGTH_X]
sensor.register_sensor(hmc.Pmake_x_sensor(conf[CONF_NAME]), conf)
if CONF_FIELD_STRENGTH_Y in config:
conf = config[CONF_FIELD_STRENGTH_Y]
sensor.register_sensor(hmc.Pmake_y_sensor(conf[CONF_NAME]), conf)
vol.Optional(CONF_REPEAT):
vol.Any(
cv.positive_not_null_int,
vol.Schema({
vol.Required(CONF_TIMES):
cv.positive_not_null_int,
vol.Required(CONF_WAIT_TIME):
cv.positive_time_period_microseconds,
vol.Optional('wait_time_us'):
cv.invalid(WAIT_TIME_MESSAGE),
})),
vol.Optional(CONF_IR_TRANSMITTER_ID):
cv.variable_id,
vol.Optional(CONF_INVERTED):
cv.invalid("IR Transmitters do not support inverted mode!"),
}).extend(switch.SWITCH_SCHEMA.schema), cv.has_at_least_one_key(*IR_KEYS))
# pylint: disable=invalid-name
ir_ns = switch.switch_ns.namespace('ir')
SendData = ir_ns.namespace('SendData')
DataTransmitter = IRTransmitterComponent.DataTransmitter
def safe_hex(value):
if value is None:
return None
return HexIntLiteral(value)
def exp_send_data(config):
if CONF_NEC in config:
pins.input_pin,
vol.Optional(CONF_VOLTAGE):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_CURRENT):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_POWER):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_CURRENT_RESISTOR):
cv.resistance,
vol.Optional(CONF_VOLTAGE_DIVIDER):
cv.positive_float,
vol.Optional(CONF_CHANGE_MODE_EVERY):
vol.All(cv.uint32_t, vol.Range(min=1)),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT, CONF_POWER))
def to_code(config):
sel = None
for sel in gpio_output_pin_expression(config[CONF_SEL_PIN]):
yield
rhs = App.make_hlw8012(sel, config[CONF_CF_PIN], config[CONF_CF1_PIN],
config.get(CONF_UPDATE_INTERVAL))
hlw = Pvariable(config[CONF_ID], rhs)
if CONF_VOLTAGE in config:
conf = config[CONF_VOLTAGE]
sensor.register_sensor(hlw.make_voltage_sensor(conf[CONF_NAME]), conf)
if CONF_CURRENT in config:
vol.Optional(CONF_EXPIRE_AFTER):
vol.Any(None, cv.positive_time_period_milliseconds),
vol.Optional(CONF_FILTERS):
FILTERS_SCHEMA,
vol.Optional(CONF_ON_VALUE):
vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA]),
vol.Optional(CONF_ON_RAW_VALUE):
vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA]),
vol.Optional(CONF_ON_VALUE_RANGE):
vol.All(cv.ensure_list, [
vol.All(
automation.AUTOMATION_SCHEMA.extend(
{
vol.Optional(CONF_ABOVE): vol.Coerce(float),
vol.Optional(CONF_BELOW): vol.Coerce(float),
}), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
]),
})
# pylint: disable=invalid-name
sensor_ns = esphomelib_ns.namespace('sensor')
Sensor = sensor_ns.Sensor
MQTTSensorComponent = sensor_ns.MQTTSensorComponent
OffsetFilter = sensor_ns.OffsetFilter
MultiplyFilter = sensor_ns.MultiplyFilter
FilterOutValueFilter = sensor_ns.FilterOutValueFilter
FilterOutNANFilter = sensor_ns.FilterOutNANFilter
SlidingWindowMovingAverageFilter = sensor_ns.SlidingWindowMovingAverageFilter
ExponentialMovingAverageFilter = sensor_ns.ExponentialMovingAverageFilter
LambdaFilter = sensor_ns.LambdaFilter
ThrottleFilter = sensor_ns.ThrottleFilter
vol.Optional(CONF_NAME, default="Random"): cv.string,
vol.Optional(CONF_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_STROBE): vol.Schema({
cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(StrobeLightEffect),
vol.Optional(CONF_NAME, default="Strobe"): cv.string,
vol.Optional(CONF_COLORS): vol.All(cv.ensure_list, [vol.All(vol.Schema({
vol.Optional(CONF_STATE, default=True): cv.boolean,
vol.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
vol.Optional(CONF_RED, default=1.0): cv.percentage,
vol.Optional(CONF_GREEN, default=1.0): cv.percentage,
vol.Optional(CONF_BLUE, default=1.0): cv.percentage,
vol.Optional(CONF_WHITE, default=1.0): cv.percentage,
vol.Required(CONF_DURATION): cv.positive_time_period_milliseconds,
}), cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE,
CONF_WHITE))], vol.Length(min=2)),
}),
vol.Optional(CONF_FLICKER): vol.Schema({
cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FlickerLightEffect),
vol.Optional(CONF_NAME, default="Flicker"): cv.string,
vol.Optional(CONF_ALPHA): cv.percentage,
vol.Optional(CONF_INTENSITY): cv.percentage,
}),
vol.Optional(CONF_FASTLED_LAMBDA): vol.Schema({
vol.Required(CONF_NAME): cv.string,
vol.Required(CONF_LAMBDA): cv.lambda_,
vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_FASTLED_RAINBOW): vol.Schema({
cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRainbowLightEffect),
vol.Optional(CONF_NAME, default="Rainbow"): cv.string,
vol.Optional(CONF_SHUNT_VOLTAGE):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_CURRENT):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_POWER):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1):
vol.All(cv.resistance, vol.Range(min=0.0, max=32.0)),
vol.Optional(CONF_MAX_VOLTAGE, default=32.0):
vol.All(cv.voltage, vol.Range(min=0.0, max=32.0)),
vol.Optional(CONF_MAX_CURRENT, default=3.2):
vol.All(cv.current, vol.Range(min=0.0)),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}),
cv.has_at_least_one_key(CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT,
CONF_POWER))
def to_code(config):
rhs = App.make_ina219(config[CONF_SHUNT_RESISTANCE],
config[CONF_MAX_CURRENT],
config[CONF_MAX_VOLTAGE], config[CONF_ADDRESS],
config.get(CONF_UPDATE_INTERVAL))
ina = Pvariable(config[CONF_ID], rhs)
if CONF_BUS_VOLTAGE in config:
conf = config[CONF_BUS_VOLTAGE]
sensor.register_sensor(ina.Pmake_bus_voltage_sensor(conf[CONF_NAME]),
conf)
if CONF_SHUNT_VOLTAGE in config:
conf = config[CONF_SHUNT_VOLTAGE]
sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(conf[CONF_NAME]),
DallasTemperatureSensor = sensor.sensor_ns.class_(
'DallasTemperatureSensor', sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(DallasTemperatureSensor),
vol.Exclusive(CONF_ADDRESS, 'dallas'):
cv.hex_int,
vol.Exclusive(CONF_INDEX, 'dallas'):
cv.positive_int,
cv.GenerateID(CONF_DALLAS_ID):
cv.use_variable_id(DallasComponent),
vol.Optional(CONF_RESOLUTION):
vol.All(vol.Coerce(int), vol.Range(min=9, max=12)),
}), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
def to_code(config):
for hub in get_variable(config[CONF_DALLAS_ID]):
yield
if CONF_ADDRESS in config:
address = HexIntLiteral(config[CONF_ADDRESS])
rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address,
config.get(CONF_RESOLUTION))
else:
rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
config.get(CONF_RESOLUTION))
sensor.register_sensor(rhs, config)
import voluptuous as vol
import esphomeyaml.config_validation as cv
from esphomeyaml import pins
from esphomeyaml.const import CONF_BAUD_RATE, CONF_ID, CONF_RX_PIN, CONF_TX_PIN
from esphomeyaml.helpers import App, Pvariable, esphomelib_ns
UARTComponent = esphomelib_ns.UARTComponent
SPI_SCHEMA = vol.All(
vol.Schema({
cv.GenerateID(): cv.declare_variable_id(UARTComponent),
vol.Optional(CONF_TX_PIN): pins.output_pin,
vol.Optional(CONF_RX_PIN): pins.input_pin,
vol.Required(CONF_BAUD_RATE): cv.positive_int,
}), cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN))
CONFIG_SCHEMA = vol.All(cv.ensure_list, [SPI_SCHEMA])
def to_code(config):
for conf in config:
tx = conf.get(CONF_TX_PIN, -1)
rx = conf.get(CONF_RX_PIN, -1)
rhs = App.init_uart(tx, rx, conf[CONF_BAUD_RATE])
Pvariable(conf[CONF_ID], rhs)
BUILD_FLAGS = '-DUSE_UART'
cv.use_variable_id(UARTComponent),
vol.Required(CONF_TYPE):
vol.All(vol.Upper, cv.one_of(*PMSX003_TYPES)),
vol.Optional(CONF_PM_1_0):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_PM_2_5):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_PM_10_0):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_TEMPERATURE):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_HUMIDITY):
cv.nameable(sensor.SENSOR_SCHEMA),
vol.Optional(CONF_FORMALDEHYDE):
cv.nameable(sensor.SENSOR_SCHEMA),
}), cv.has_at_least_one_key(*SENSORS_TO_TYPE))
def to_code(config):
for uart in get_variable(config[CONF_UART_ID]):
yield
rhs = App.make_pmsx003(uart, PMSX003_TYPES[config[CONF_TYPE]])
pms = Pvariable(config[CONF_ID], rhs)
if CONF_PM_1_0 in config:
conf = config[CONF_PM_1_0]
sensor.register_sensor(pms.make_pm_1_0_sensor(conf[CONF_NAME]), conf)
if CONF_PM_2_5 in config:
conf = config[CONF_PM_2_5]
PLATFORM_SCHEMA = vol.All(
cover.PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeTemplateCover),
vol.Optional(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_OPTIMISTIC):
cv.boolean,
vol.Optional(CONF_OPEN_ACTION):
automation.ACTIONS_SCHEMA,
vol.Optional(CONF_CLOSE_ACTION):
automation.ACTIONS_SCHEMA,
vol.Optional(CONF_STOP_ACTION):
automation.ACTIONS_SCHEMA,
}).extend(cover.COVER_SCHEMA.schema),
cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
def to_code(config):
rhs = App.make_template_cover(config[CONF_NAME])
make = variable(config[CONF_MAKE_ID], rhs)
if CONF_LAMBDA in config:
template_ = None
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=optional.template(
cover.CoverState)):
yield
add(make.Ptemplate_.set_state_lambda(template_))
if CONF_OPEN_ACTION in config:
actions = None
import voluptuous as vol
import esphomeyaml.config_validation as cv
from esphomeyaml.components import sensor
from esphomeyaml.components.dallas import DallasComponent
from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
CONF_RESOLUTION, CONF_UPDATE_INTERVAL
from esphomeyaml.helpers import HexIntLiteral, get_variable
PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
vol.Exclusive(CONF_ADDRESS, 'dallas'): cv.hex_int,
vol.Exclusive(CONF_INDEX, 'dallas'): cv.positive_int,
vol.Optional(CONF_DALLAS_ID): cv.variable_id,
vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=8, max=12)),
}).extend(sensor.SENSOR_SCHEMA.schema), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
def to_code(config):
hub = get_variable(config.get(CONF_DALLAS_ID), DallasComponent)
update_interval = config.get(CONF_UPDATE_INTERVAL)
if CONF_RESOLUTION in config and update_interval is None:
update_interval = 10000
if CONF_ADDRESS in config:
address = HexIntLiteral(config[CONF_ADDRESS])
rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address, update_interval,
config.get(CONF_RESOLUTION))
else:
rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
update_interval, config.get(CONF_RESOLUTION))
sensor.register_sensor(rhs, config)
