def elevation(value):
if isinstance(value, str):
try:
value = ELEVATION_MAP[cv.one_of(*ELEVATION_MAP, lower=True, space='_')]
except cv.Invalid:
pass
value = cv.angle(value)
return cv.float_range(min=-180, max=180)(value)
cv.Optional(CONF_AP):
WIFI_NETWORK_AP,
cv.Optional(CONF_ENABLE_MDNS, default=True):
cv.boolean,
cv.Optional(CONF_DOMAIN, default=".local"):
cv.domain_name,
cv.Optional(CONF_REBOOT_TIMEOUT, default="15min"):
cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266="none", esp32="light"):
cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False):
cv.boolean,
cv.Optional(CONF_USE_ADDRESS):
cv.string_strict,
cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0):
cv.All(cv.decibel, cv.float_range(min=10.0, max=20.5)),
cv.Optional("hostname"):
cv.invalid("The hostname option has been removed in 1.11.0"),
}),
validate,
)
def eap_auth(config):
if config is None:
return None
ca_cert = ""
if CONF_CERTIFICATE_AUTHORITY in config:
ca_cert = wpa2_eap.read_relative_config_path(
config[CONF_CERTIFICATE_AUTHORITY])
client_cert = ""
CONF_TEMP_OFFSET = 'temperature_offset'
CONF_IAQ_MODE = 'iaq_mode'
CONF_STATE_SAVE_INTERVAL = 'state_save_interval'
bme680_bsec_ns = cg.esphome_ns.namespace('bme680_bsec')
BME680IAQMode = bme680_bsec_ns.enum('BME680IAQMode')
IAQ_MODE_OPTIONS = {
'STATIC': BME680IAQMode.BME680_IAQ_MODE_STATIC,
'MOBILE': BME680IAQMode.BME680_IAQ_MODE_MOBILE,
}
BME680BSECComponent = bme680_bsec_ns.class_('BME680BSECComponent', cg.Component, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(BME680BSECComponent),
cv.Optional(CONF_TEMP_OFFSET, default=0): cv.float_range(min=-100, max=100),
cv.Optional(CONF_IAQ_MODE, default='STATIC'):
cv.enum(IAQ_MODE_OPTIONS, upper=True),
cv.Optional(CONF_STATE_SAVE_INTERVAL, default='6hours'): cv.positive_time_period_minutes,
}).extend(i2c.i2c_device_schema(0x76))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
cg.add(var.set_temperature_offset(config[CONF_TEMP_OFFSET]))
cg.add(var.set_iaq_mode(config[CONF_IAQ_MODE]))
cg.add(var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL]))
CONFIG_SECONDARY = cv.Schema({
cv.GenerateID(): cv.declare_id(i2c.I2CDevice)
}).extend(i2c.i2c_device_schema(None))
CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(HT16K33AlphaDisplay),
cv.Optional(CONF_SCROLL, default=False):
cv.boolean,
cv.Optional(CONF_SCROLL_SPEED, default='250ms'):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_SCROLL_DWELL, default='2s'):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_SCROLL_DELAY, default='3'):
cv.float_range(min=1),
cv.Optional(CONF_SECONDARY_DISPLAYS):
cv.ensure_list(CONFIG_SECONDARY),
}).extend(cv.polling_component_schema('1s')).extend(
i2c.i2c_device_schema(0x70))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield display.register_display(var, config)
yield i2c.register_i2c_device(var, config)
if CONF_LAMBDA in config:
lambda_ = yield cg.process_lambda(
config[CONF_LAMBDA], [(HT16K33AlphaDisplay.operator('ref'), 'it')],
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_ID, UNIT_METER, ICON_ARROW_EXPAND_VERTICAL
DEPENDENCIES = ['i2c']
vl53l0x_ns = cg.esphome_ns.namespace('vl53l0x')
VL53L0XSensor = vl53l0x_ns.class_('VL53L0XSensor', sensor.Sensor, cg.PollingComponent,
i2c.I2CDevice)
CONF_SIGNAL_RATE_LIMIT = 'signal_rate_limit'
CONF_LONG_RANGE = 'long_range'
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_METER, ICON_ARROW_EXPAND_VERTICAL, 2).extend({
cv.GenerateID(): cv.declare_id(VL53L0XSensor),
cv.Optional(CONF_SIGNAL_RATE_LIMIT, default=0.25): cv.float_range(
min=0.0, max=512.0, min_included=False, max_included=False),
cv.Optional(CONF_LONG_RANGE, default=False): cv.boolean,
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x29))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(var.set_signal_rate_limit(config[CONF_SIGNAL_RATE_LIMIT]))
cg.add(var.set_long_range(config[CONF_LONG_RANGE]))
yield sensor.register_sensor(var, config)
yield i2c.register_i2c_device(var, config)
d = m.group(5)
val = float(deg or 0) + float(minute or 0) / 60 + float(second or 0) / 3600
if sign == "-":
val *= -1
if d and d in "SW":
val *= -1
return val
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.All(
parse_latlon, cv.float_range(min=-90, max=90)
),
cv.Required(CONF_LONGITUDE): cv.All(
parse_latlon, 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),
cv.Optional(CONF_ELEVATION, default=DEFAULT_ELEVATION): elevation,
}
def validate_driver_address(value):
if value < 0 or value > 3:
raise cv.Invalid(
"Driver address must be 0 to 3 according to MS1 and MS2"
)
return value
CONFIG_SCHEMA = cv.All(
stepper.STEPPER_SCHEMA.extend ({
cv.Required(CONF_ID): cv.declare_id(TMC2209),
# Match to your driver
# SilentStepStick series use 0.11
# UltiMachine Einsy and Archim2 boards use 0.2
# Panucatt BSD2660 uses 0.1
# Watterott TMC5160 uses 0.075
cv.Required(CONF_R_SENSE): cv.float_range(min=0,max=1),
cv.Required(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_INDEX_PIN): validate_index_counter_pin,
cv.Optional(CONF_DIAG_PIN): pins.gpio_input_pin_schema,
cv.Optional(CONF_STEP_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_DIR_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_FREEWHEELING_MODE, default="normal"): cv.enum({"normal": 0, "freewheeling": 1, "shorted_coil_ls": 2, "shorted_coil_hs": 3}),
cv.Optional(CONF_INVERTED, False): cv.boolean,
cv.Optional(CONF_DRIVER_ADDRESS, default=0): validate_driver_address,
# StallGuard4 threshold [0... 255] level for stall detection. It compensates for
# motor specific characteristics and controls sensitivity. A higher value gives a higher
# sensitivity. A higher value makes StallGuard4 more sensitive and requires less torque to
# indicate a stall. The double of this value is compared to SG_RESULT.
# The stall output becomes active if SG_RESULT fall below this value.
cv.Optional(CONF_STALL_THRESHOLD, default=0): cv.int_range(min=0,max=255),
cv.Optional(CONF_MICROSTEPS, default=0): cv.one_of(0,2,4,8,16,32,64,128,256, int=True),
CometBlueClimate = cg.global_ns.class_('CometBlueClimate', climate.Climate,
cg.PollingComponent)
CONFIG_SCHEMA = cv.All(
climate.CLIMATE_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(CometBlueClimate),
cv.GenerateID(CONF_TIME_ID):
cv.use_id(time.RealTimeClock),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_PIN, default=-1):
cv.int_range(min_included=0, max_included=9999999),
cv.Optional(CONF_TEMPERATURE_OFFSET, default=0):
cv.float_range(min_included=-3, max_included=+3),
cv.Optional(CONF_WINDOW_OPEN_SENSITIVITY, default=4):
cv.int_range(min_included=0, max_included=4),
cv.Optional(CONF_WINDOW_OPEN_MINUTES, default=10):
cv.int_range(min_included=0, max_included=60),
}).extend(cv.polling_component_schema('4h')))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield climate.register_climate(var, config)
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
cg.add(var.set_pin(config[CONF_PIN]))
cg.add(var.set_temperature_offset(config[CONF_TEMPERATURE_OFFSET]))
cv.GenerateID():
cv.declare_id(LTR390Component),
cv.Optional(CONF_LIGHT):
sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1),
cv.Optional(CONF_ALS):
sensor.sensor_schema(UNIT_COUNTS, ICON_BRIGHTNESS_5, 1),
cv.Optional(CONF_UVI):
sensor.sensor_schema(UNIT_UVI, ICON_BRIGHTNESS_5, 5),
cv.Optional(CONF_UV):
sensor.sensor_schema(UNIT_COUNTS, ICON_BRIGHTNESS_5, 1),
cv.Optional(CONF_GAIN, default="X3"):
cv.enum(GAIN_OPTIONS),
cv.Optional(CONF_RESOLUTION, default="18"):
cv.enum(RES_OPTIONS),
cv.Optional(CONF_WFAC, default=1.0):
cv.float_range(min=1.0),
}).extend(cv.polling_component_schema('60s')).extend(
i2c.i2c_device_schema(0x53))
TYPES = {
CONF_LIGHT: 'set_light_sensor',
CONF_ALS: 'set_als_sensor',
CONF_UVI: 'set_uvi_sensor',
CONF_UV: 'set_uv_sensor',
}
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
icon=ICON_WATER_PERCENT,
accuracy_decimals=2,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_PRECISION, default="High"):
cv.enum(PRECISION_OPTIONS),
cv.Optional(CONF_HEATER_POWER, default="High"):
cv.enum(HEATER_POWER_OPTIONS),
cv.Optional(CONF_HEATER_TIME, default="Long"):
cv.enum(HEATER_TIME_OPTIONS),
cv.Optional(CONF_HEATER_MAX_DUTY, default=0.0):
cv.float_range(min=0.0, max=0.05),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x44)))
TYPES = {
CONF_TEMPERATURE: "set_temp_sensor",
CONF_HUMIDITY: "set_humidity_sensor",
}
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
cg.add(var.set_precision_value(config[CONF_PRECISION]))
if value.total_seconds > 60:
raise cv.Invalid("Maximum timeout can not be greater then 60 seconds")
return value
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(
VL53L0XSensor,
unit_of_measurement=UNIT_METER,
icon=ICON_ARROW_EXPAND_VERTICAL,
accuracy_decimals=2,
state_class=STATE_CLASS_MEASUREMENT,
).extend({
cv.Optional(CONF_SIGNAL_RATE_LIMIT, default=0.25):
cv.float_range(min=0.0,
max=512.0,
min_included=False,
max_included=False),
cv.Optional(CONF_LONG_RANGE, default=False):
cv.boolean,
cv.Optional(CONF_TIMEOUT, default="10ms"):
check_timeout,
cv.Optional(CONF_ENABLE_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x29)),
check_keys,
)
async def to_code(config):
var = await sensor.new_sensor(config)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(TCS34725Component),
cv.Optional(CONF_RED_CHANNEL): color_channel_schema,
cv.Optional(CONF_GREEN_CHANNEL): color_channel_schema,
cv.Optional(CONF_BLUE_CHANNEL): color_channel_schema,
cv.Optional(CONF_CLEAR_CHANNEL): color_channel_schema,
cv.Optional(CONF_ILLUMINANCE): illuminance_schema,
cv.Optional(CONF_COLOR_TEMPERATURE): color_temperature_schema,
cv.Optional(CONF_INTEGRATION_TIME, default="auto"): cv.enum(
TCS34725_INTEGRATION_TIMES, lower=True
),
cv.Optional(CONF_GAIN, default="1X"): cv.enum(TCS34725_GAINS, upper=True),
cv.Optional(CONF_GLASS_ATTENUATION_FACTOR, default=1.0): cv.float_range(
min=1.0
),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(i2c.i2c_device_schema(0x29))
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
cg.add(var.set_integration_time(config[CONF_INTEGRATION_TIME]))
cg.add(var.set_gain(config[CONF_GAIN]))
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),
cv.Optional(CONF_ELEVATION, default=DEFAULT_ELEVATION):
elevation,
cv.enum(DIRECTION_TYPE, upper=True),
})
GRAPH_SCHEMA = cv.Schema({
cv.Required(CONF_ID):
cv.declare_id(Graph_),
cv.Required(CONF_DURATION):
cv.positive_time_period_seconds,
cv.Required(CONF_WIDTH):
cv.positive_not_null_int,
cv.Required(CONF_HEIGHT):
cv.positive_not_null_int,
cv.Optional(CONF_X_GRID):
cv.positive_time_period_seconds,
cv.Optional(CONF_Y_GRID):
cv.float_range(min=0, min_included=False),
cv.Optional(CONF_BORDER):
cv.boolean,
# Single trace options in base
cv.Optional(CONF_SENSOR):
cv.use_id(sensor.Sensor),
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),
# Axis specific options (Future feature may be to add second Y-axis)
cv.Optional(CONF_MIN_VALUE):
cv.float_,
cv.Optional(CONF_MAX_VALUE):
def elevation(value):
if isinstance(value, str):
try:
value = ELEVATION_MAP[cv.one_of(*ELEVATION_MAP, lower=True, space='_')]
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=0.0): elevation,
}),
cv.Optional(CONF_ON_SUNSET): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SunTrigger),
cv.Optional(CONF_ELEVATION, default=0.0): elevation,
}),
})
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
cv.Optional(CONF_EAP):
EAP_AUTH_SCHEMA,
cv.Optional(CONF_AP):
wifi_network_ap,
cv.Optional(CONF_DOMAIN, default=".local"):
cv.domain_name,
cv.Optional(CONF_REBOOT_TIMEOUT, default="15min"):
cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266="none", esp32="light"):
cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False):
cv.boolean,
cv.Optional(CONF_USE_ADDRESS):
cv.string_strict,
cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0):
cv.All(cv.decibel, cv.float_range(min=8.5, max=20.5)),
cv.Optional("enable_mdns"):
cv.invalid(
"This option has been removed. Please use the [disabled] option under the "
"new mdns component instead."),
}),
_validate,
)
def eap_auth(config):
if config is None:
return None
ca_cert = ""
if CONF_CERTIFICATE_AUTHORITY in config:
ca_cert = wpa2_eap.read_relative_config_path(