CONF_POSITION_ACTION
from .. import template_ns
TemplateCover = template_ns.class_('TemplateCover', cover.Cover, cg.Component)
TemplateCoverRestoreMode = template_ns.enum('TemplateCoverRestoreMode')
RESTORE_MODES = {
'NO_RESTORE': TemplateCoverRestoreMode.COVER_NO_RESTORE,
'RESTORE': TemplateCoverRestoreMode.COVER_RESTORE,
'RESTORE_AND_CALL': TemplateCoverRestoreMode.COVER_RESTORE_AND_CALL,
}
CONF_HAS_POSITION = 'has_position'
CONFIG_SCHEMA = cover.COVER_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(TemplateCover),
cv.Optional(CONF_LAMBDA): cv.returning_lambda,
cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
cv.Optional(CONF_HAS_POSITION, default=False): cv.boolean,
cv.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_TILT_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_TILT_LAMBDA): cv.returning_lambda,
cv.Optional(CONF_POSITION_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_RESTORE_MODE, default='RESTORE'): cv.enum(RESTORE_MODES, upper=True),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
)
return cv.file_(value)
DEFAULT_GLYPHS = (
' !"%()+,-.:0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz°'
)
CONF_RAW_DATA_ID = "raw_data_id"
FONT_SCHEMA = cv.Schema(
{
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.int_range(min=1),
cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
}
)
CONFIG_SCHEMA = cv.All(validate_pillow_installed, FONT_SCHEMA)
def to_code(config):
from PIL import ImageFont
path = CORE.relative_config_path(config[CONF_FILE])
try:
font = ImageFont.truetype(path, config[CONF_SIZE])
except Exception as e:
raise core.EsphomeError(f"Could not load truetype file {path}: {e}")
from esphome.components import display, spi
from esphome.const import CONF_ID, CONF_LAMBDA
from esphome.const import CONF_DC_PIN, CONF_CS_PIN, CONF_ID, CONF_LAMBDA, CONF_PAGES
from esphome.const import CONF_EXTERNAL_VCC, CONF_LAMBDA, CONF_MODEL, CONF_RESET_PIN, \
CONF_BRIGHTNESS
from . import st7789v_ns
DEPENDENCIES = ['spi']
CONF_BACKLIGHT_PIN = 'bl_pin'
ST7789V = st7789v_ns.class_('ST7789V', cg.PollingComponent, spi.SPIDevice)
ST7789VRef = ST7789V.operator('ref')
CONFIG_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(ST7789V),
cv.Required(CONF_RESET_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_BACKLIGHT_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
}).extend(cv.polling_component_schema('1s')).extend(spi.SPI_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))
UNIT_VOLT,
UNIT_AMPERE,
UNIT_WATT,
)
DEPENDENCIES = ["uart"]
cse7766_ns = cg.esphome_ns.namespace("cse7766")
CSE7766Component = cse7766_ns.class_(
"CSE7766Component", cg.PollingComponent, uart.UARTDevice
)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(CSE7766Component),
cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE
),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(
UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT
),
cv.Optional(CONF_POWER): sensor.sensor_schema(
UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER
),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(uart.UART_DEVICE_SCHEMA)
)
CONF_UPDATE_INTERVAL
from esphome.cpp_generator import Pvariable, get_variable
from esphome.cpp_helpers import setup_component
from esphome.cpp_types import App, PollingComponent
DEPENDENCIES = ['uart']
MHZ19Component = sensor.sensor_ns.class_('MHZ19Component', PollingComponent,
uart.UARTDevice)
MHZ19TemperatureSensor = sensor.sensor_ns.class_(
'MHZ19TemperatureSensor', sensor.EmptyPollingParentSensor)
MHZ19CO2Sensor = sensor.sensor_ns.class_('MHZ19CO2Sensor',
sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MHZ19Component),
cv.GenerateID(CONF_UART_ID):
cv.use_variable_id(UARTComponent),
vol.Required(CONF_CO2):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MHZ19CO2Sensor),
})),
vol.Optional(CONF_TEMPERATURE):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MHZ19TemperatureSensor),
})),
parts_int = []
if any(len(part) != 2 for part in parts):
raise cv.Invalid("Decryption key must be format XX")
for part in parts:
try:
parts_int.append(int(part, 16))
except ValueError:
# pylint: disable=raise-missing-from
raise cv.Invalid("Decryption key must be hex values from 00 to FF")
return "".join(f"{part:02X}" for part in parts_int)
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID(): cv.declare_id(Dsmr),
cv.Optional(CONF_DECRYPTION_KEY): _validate_key,
cv.Optional(CONF_CRC_CHECK, default=True): cv.boolean,
cv.Optional(CONF_GAS_MBUS_ID, default=1): cv.int_,
}).extend(uart.UART_DEVICE_SCHEMA),
cv.only_with_arduino,
)
async def to_code(config):
uart_component = await cg.get_variable(config[CONF_UART_ID])
var = cg.new_Pvariable(config[CONF_ID], uart_component,
config[CONF_CRC_CHECK])
if CONF_DECRYPTION_KEY in config:
cg.add(var.set_decryption_key(config[CONF_DECRYPTION_KEY]))
await cg.register_component(var, config)
import esphome.config_validation as cv
from esphome.components import sensor, esp32_ble_tracker
from esphome.const import CONF_MAC_ADDRESS, CONF_TEMPERATURE, \
UNIT_CELSIUS, ICON_THERMOMETER, UNIT_PERCENT, ICON_WATER_PERCENT, CONF_ID, \
CONF_MOISTURE, CONF_ILLUMINANCE, ICON_BRIGHTNESS_5, UNIT_LUX, CONF_CONDUCTIVITY, \
UNIT_MICROSIEMENS_PER_CENTIMETER, ICON_FLOWER
DEPENDENCIES = ['esp32_ble_tracker']
AUTO_LOAD = ['xiaomi_ble']
xiaomi_hhccjcy01_ns = cg.esphome_ns.namespace('xiaomi_hhccjcy01')
XiaomiHHCCJCY01 = xiaomi_hhccjcy01_ns.class_('XiaomiHHCCJCY01',
esp32_ble_tracker.ESPBTDeviceListener, cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(XiaomiHHCCJCY01),
cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_MOISTURE): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0),
cv.Optional(CONF_ILLUMINANCE): sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 0),
cv.Optional(CONF_CONDUCTIVITY):
sensor.sensor_schema(UNIT_MICROSIEMENS_PER_CENTIMETER, ICON_FLOWER, 0),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield esp32_ble_tracker.register_ble_device(var, config)
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
if update_interval.total_minutes > 30:
raise cv.Invalid("Maximum update interval is 30min")
elif value.get(CONF_RX_ONLY) and CONF_UPDATE_INTERVAL in value:
# update_interval does not affect anything in rx-only mode, let's warn user about
# that
raise cv.Invalid(
"update_interval has no effect in rx_only mode. Please remove it.",
path=["update_interval"],
)
return value
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(SDS011Component),
cv.Optional(CONF_PM_2_5): sensor.sensor_schema(
unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
icon=ICON_CHEMICAL_WEAPON,
accuracy_decimals=1,
device_class=DEVICE_CLASS_PM25,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_PM_10_0): sensor.sensor_schema(
unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
icon=ICON_CHEMICAL_WEAPON,
accuracy_decimals=1,
device_class=DEVICE_CLASS_PM10,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_RX_ONLY, default=False): cv.boolean,
if (
config.get(CONF_VERIFY_SSL)
and not isinstance(url_, Lambda)
and url_.lower().startswith("https:")
):
raise cv.Invalid(
"Currently ESPHome doesn't support SSL verification. "
"Set 'verify_ssl: false' to make insecure HTTPS requests."
)
return config
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(HttpRequestComponent),
cv.Optional(CONF_USERAGENT, "ESPHome"): cv.string,
cv.Optional(
CONF_TIMEOUT, default="5s"
): cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_ESP8266_DISABLE_SSL_SUPPORT, esp8266=False): cv.All(
cv.only_on_esp8266, cv.boolean
),
}
).extend(cv.COMPONENT_SCHEMA),
cv.require_framework_version(
esp8266_arduino=cv.Version(2, 5, 1),
esp32_arduino=cv.Version(0, 0, 0),
),
)
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import ICON_ROTATE_RIGHT, CONF_ID, UNIT_DEGREES, CONF_ROTATION
polehealth_ns = cg.esphome_ns.namespace('polehealth')
PoleHealthSensor = polehealth_ns.class_('PoleHealthSensor', cg.Component, sensor.Sensor)
rotation_schema = sensor.sensor_schema(UNIT_DEGREES, ICON_ROTATE_RIGHT, 1)
CONF_ACCEL_X = "in_accel_x"
CONF_ACCEL_Y = "in_accel_y"
CONF_ACCEL_Z = "in_accel_z"
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_DEGREES, ICON_ROTATE_RIGHT, 1).extend({
cv.GenerateID(): cv.declare_id(PoleHealthSensor),
cv.Required(CONF_ACCEL_X): cv.use_id(sensor.Sensor),
cv.Required(CONF_ACCEL_Y): cv.use_id(sensor.Sensor),
cv.Required(CONF_ACCEL_Z): cv.use_id(sensor.Sensor),
cv.Optional(CONF_ROTATION): rotation_schema,
}).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_x = yield cg.get_variable(config[CONF_ACCEL_X])
cg.add(var.set_accel_x(sens_x))
sens_y = yield cg.get_variable(config[CONF_ACCEL_Y])
import voluptuous as vol
from esphome.components import light, output
import esphome.config_validation as cv
from esphome.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, \
CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED
from esphome.cpp_generator import get_variable, variable
from esphome.cpp_helpers import setup_component
from esphome.cpp_types import App
PLATFORM_SCHEMA = cv.nameable(
light.LIGHT_PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(light.MakeLight),
vol.Required(CONF_RED):
cv.use_variable_id(output.FloatOutput),
vol.Required(CONF_GREEN):
cv.use_variable_id(output.FloatOutput),
vol.Required(CONF_BLUE):
cv.use_variable_id(output.FloatOutput),
vol.Optional(CONF_GAMMA_CORRECT):
cv.positive_float,
vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_EFFECTS):
light.validate_effects(light.RGB_EFFECTS),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for red in get_variable(config[CONF_RED]):
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import (
CONF_DISTANCE,
CONF_LIGHTNING_ENERGY,
STATE_CLASS_NONE,
UNIT_KILOMETER,
ICON_SIGNAL_DISTANCE_VARIANT,
ICON_FLASH,
)
from . import AS3935, CONF_AS3935_ID
DEPENDENCIES = ["as3935"]
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_AS3935_ID):
cv.use_id(AS3935),
cv.Optional(CONF_DISTANCE):
sensor.sensor_schema(
unit_of_measurement=UNIT_KILOMETER,
icon=ICON_SIGNAL_DISTANCE_VARIANT,
accuracy_decimals=1,
state_class=STATE_CLASS_NONE,
),
cv.Optional(CONF_LIGHTNING_ENERGY):
sensor.sensor_schema(
icon=ICON_FLASH,
accuracy_decimals=1,
state_class=STATE_CLASS_NONE,
),
}).extend(cv.COMPONENT_SCHEMA)
MODELS = {
'SSD1306_128X32': SSD1306Model.SSD1306_MODEL_128_32,
'SSD1306_128X64': SSD1306Model.SSD1306_MODEL_128_64,
'SSD1306_96X16': SSD1306Model.SSD1306_MODEL_96_16,
'SSD1306_64X48': SSD1306Model.SSD1306_MODEL_64_48,
'SH1106_128X32': SSD1306Model.SH1106_MODEL_128_32,
'SH1106_128X64': SSD1306Model.SH1106_MODEL_128_64,
'SH1106_96X16': SSD1306Model.SH1106_MODEL_96_16,
'SH1106_64X48': SSD1306Model.SH1106_MODEL_64_48,
}
SSD1306_MODEL = cv.one_of(*MODELS, upper=True, space="_")
PLATFORM_SCHEMA = vol.All(
display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(SPISSD1306),
cv.GenerateID(CONF_SPI_ID):
cv.use_variable_id(SPIComponent),
vol.Required(CONF_CS_PIN):
pins.gpio_output_pin_schema,
vol.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
vol.Required(CONF_MODEL):
SSD1306_MODEL,
vol.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_EXTERNAL_VCC):
cv.boolean,
}).extend(cv.COMPONENT_SCHEMA.schema),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
UNIT_EMPTY,
UNIT_CELSIUS,
UNIT_PERCENT,
UNIT_VOLT,
)
DEPENDENCIES = ["uart"]
smt100_ns = cg.esphome_ns.namespace("smt100")
SMT100 = smt100_ns.class_("SMT100Component", cg.PollingComponent, uart.UARTDevice)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(SMT100),
cv.Optional(CONF_COUNTS): sensor.sensor_schema(
unit_of_measurement=UNIT_EMPTY,
accuracy_decimals=0,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_DIELECTRIC_CONSTANT): sensor.sensor_schema(
unit_of_measurement=UNIT_EMPTY,
accuracy_decimals=2,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=2,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import esp32_ble_tracker
from esphome.const import CONF_ID
DEPENDENCIES = ["esp32_ble_tracker"]
CODEOWNERS = ["@jeromelaban"]
airthings_ble_ns = cg.esphome_ns.namespace("airthings_ble")
AirthingsListener = airthings_ble_ns.class_(
"AirthingsListener", esp32_ble_tracker.ESPBTDeviceListener
)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(AirthingsListener),
}
).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield esp32_ble_tracker.register_ble_device(var, config)
BLESensor = ble_client_ns.class_(
"BLESensor", sensor.Sensor, cg.PollingComponent, ble_client.BLEClientNode
)
BLESensorNotifyTrigger = ble_client_ns.class_(
"BLESensorNotifyTrigger", automation.Trigger.template(cg.float_)
)
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(
accuracy_decimals=0,
state_class=STATE_CLASS_NONE,
)
.extend(
{
cv.GenerateID(): cv.declare_id(BLESensor),
cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
cv.Optional(CONF_DESCRIPTOR_UUID): esp32_ble_tracker.bt_uuid,
cv.Optional(CONF_LAMBDA): cv.returning_lambda,
cv.Optional(CONF_NOTIFY, default=False): cv.boolean,
cv.Optional(CONF_ON_NOTIFY): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
BLESensorNotifyTrigger
),
}
),
}
)
.extend(cv.polling_component_schema("60s"))
AUTO_LOAD = ["climate", "sensor", "midea_dongle"]
CODEOWNERS = ["@dudanov"]
CONF_BEEPER = "beeper"
CONF_SWING_HORIZONTAL = "swing_horizontal"
CONF_SWING_BOTH = "swing_both"
CONF_OUTDOOR_TEMPERATURE = "outdoor_temperature"
CONF_POWER_USAGE = "power_usage"
CONF_HUMIDITY_SETPOINT = "humidity_setpoint"
midea_ac_ns = cg.esphome_ns.namespace("midea_ac")
MideaAC = midea_ac_ns.class_("MideaAC", climate.Climate, cg.Component)
CONFIG_SCHEMA = cv.All(
climate.CLIMATE_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(MideaAC),
cv.GenerateID(CONF_MIDEA_DONGLE_ID): cv.use_id(MideaDongle),
cv.Optional(CONF_BEEPER, default=False): cv.boolean,
cv.Optional(CONF_SWING_HORIZONTAL, default=False): cv.boolean,
cv.Optional(CONF_SWING_BOTH, default=False): cv.boolean,
cv.Optional(CONF_OUTDOOR_TEMPERATURE): sensor.sensor_schema(
UNIT_CELSIUS, ICON_THERMOMETER, 0, DEVICE_CLASS_TEMPERATURE
),
cv.Optional(CONF_POWER_USAGE): sensor.sensor_schema(
UNIT_WATT, ICON_POWER, 0, DEVICE_CLASS_POWER
),
cv.Optional(CONF_HUMIDITY_SETPOINT): sensor.sensor_schema(
UNIT_PERCENT, ICON_WATER_PERCENT, 0, DEVICE_CLASS_HUMIDITY
),
}
).extend(cv.COMPONENT_SCHEMA)
import voluptuous as vol
from esphome import pins
from esphome.components import sensor, spi
from esphome.components.spi import SPIComponent
import esphome.config_validation as cv
from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, CONF_UPDATE_INTERVAL
from esphome.cpp_generator import Pvariable, get_variable
from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
from esphome.cpp_types import App
MAX31855Sensor = sensor.sensor_ns.class_('MAX31855Sensor', sensor.PollingSensorComponent,
spi.SPIDevice)
PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(MAX31855Sensor),
cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for spi_ in get_variable(config[CONF_SPI_ID]):
yield
for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
yield
rhs = App.make_max31855_sensor(config[CONF_NAME], spi_, cs,
config.get(CONF_UPDATE_INTERVAL))
max31855 = Pvariable(config[CONF_ID], rhs)
sensor.setup_sensor(max31855, config)
CONF_QOS: 0,
CONF_RETAIN: True,
}
return out
def validate_fingerprint(value):
value = cv.string(value)
if re.match(r"^[0-9a-f]{40}$", value) is None:
raise cv.Invalid("fingerprint must be valid SHA1 hash")
return value
CONFIG_SCHEMA = cv.All(
cv.Schema({
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):
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,
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import text_sensor
from esphome.const import CONF_ICON, CONF_ID, CONF_STATUS
from . import DalyBmsComponent, CONF_BMS_DALY_ID
ICON_CAR_BATTERY = "mdi:car-battery"
TYPES = [
CONF_STATUS,
]
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(CONF_BMS_DALY_ID): cv.use_id(DalyBmsComponent),
cv.Optional(CONF_STATUS): text_sensor.TEXT_SENSOR_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(text_sensor.TextSensor),
cv.Optional(CONF_ICON, default=ICON_CAR_BATTERY): cv.icon,
}
),
}
).extend(cv.COMPONENT_SCHEMA)
)
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
sens = cg.new_Pvariable(conf[CONF_ID])
"MOBILE": IAQMode.IAQ_MODE_MOBILE,
}
SampleRate = bme680_bsec_ns.enum("SampleRate")
SAMPLE_RATE_OPTIONS = {
"LP": SampleRate.SAMPLE_RATE_LP,
"ULP": SampleRate.SAMPLE_RATE_ULP,
}
BME680BSECComponent = bme680_bsec_ns.class_(
"BME680BSECComponent", cg.Component, i2c.I2CDevice
)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(BME680BSECComponent),
cv.Optional(CONF_TEMPERATURE_OFFSET, default=0): cv.temperature,
cv.Optional(CONF_IAQ_MODE, default="STATIC"): cv.enum(
IAQ_MODE_OPTIONS, upper=True
),
cv.Optional(CONF_SAMPLE_RATE, default="LP"): cv.enum(
SAMPLE_RATE_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):
if CONF_CLOCK_PIN in config or CONF_DATA_PIN in config:
raise cv.Invalid(
"Cannot specify both 'pin' and 'clock_pin'+'data_pin'")
return config
if CONF_CLOCK_PIN in config:
if CONF_DATA_PIN not in config:
raise cv.Invalid(
"If you give clock_pin, you must also specify data_pin")
return config
raise cv.Invalid(
"Must specify at least one of 'pin' or 'clock_pin'+'data_pin'")
CONFIG_SCHEMA = cv.All(
light.ADDRESSABLE_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID):
cv.declare_id(NeoPixelBusLightOutputBase),
cv.Optional(CONF_TYPE, default="GRB"):
validate_type,
cv.Optional(CONF_VARIANT, default="800KBPS"):
validate_variant,
cv.Optional(CONF_METHOD, default=None):
validate_method,
cv.Optional(CONF_INVERT, default="no"):
cv.boolean,
cv.Optional(CONF_PIN):
pins.output_pin,
cv.Optional(CONF_CLOCK_PIN):
pins.output_pin,
cv.Optional(CONF_DATA_PIN):
pins.output_pin,
import voluptuous as vol
from esphome.components import sensor
import esphome.config_validation as cv
from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
from esphome.cpp_generator import Pvariable
from esphome.cpp_types import App
DEPENDENCIES = ['api']
HomeassistantSensor = sensor.sensor_ns.class_('HomeassistantSensor', sensor.Sensor)
PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(HomeassistantSensor),
vol.Required(CONF_ENTITY_ID): cv.entity_id,
}))
def to_code(config):
rhs = App.make_homeassistant_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
subs = Pvariable(config[CONF_ID], rhs)
sensor.setup_sensor(subs, config)
BUILD_FLAGS = '-DUSE_HOMEASSISTANT_SENSOR'
def to_hass_config(data, config):
return sensor.core_to_hass_config(data, config)
DEPENDENCIES = ["uart"]
AUTO_LOAD = ["sensor"]
CODEOWNERS = ["@coogle"]
gps_ns = cg.esphome_ns.namespace("gps")
GPS = gps_ns.class_("GPS", cg.Component, uart.UARTDevice)
GPSListener = gps_ns.class_("GPSListener")
CONF_GPS_ID = "gps_id"
MULTI_CONF = True
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(GPS),
cv.Optional(CONF_LATITUDE): sensor.sensor_schema(
unit_of_measurement=UNIT_DEGREES,
accuracy_decimals=6,
),
cv.Optional(CONF_LONGITUDE): sensor.sensor_schema(
unit_of_measurement=UNIT_DEGREES,
accuracy_decimals=6,
),
cv.Optional(CONF_SPEED): sensor.sensor_schema(
unit_of_measurement=UNIT_KILOMETER_PER_HOUR,
accuracy_decimals=6,
),
cv.Optional(CONF_COURSE): sensor.sensor_schema(
unit_of_measurement=UNIT_DEGREES,
accuracy_decimals=2,
from_strings = [conf[CONF_FROM] for conf in config]
to_strings = [conf[CONF_TO] for conf in config]
return cg.new_Pvariable(filter_id, from_strings, to_strings)
icon = cv.icon
TEXT_SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
cv.MQTT_COMPONENT_SCHEMA).extend({
cv.OnlyWith(CONF_MQTT_ID, "mqtt"):
cv.declare_id(mqtt.MQTTTextSensor),
cv.Optional(CONF_FILTERS):
validate_filters,
cv.Optional(CONF_ON_VALUE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(TextSensorStateTrigger),
}),
cv.Optional(CONF_ON_RAW_VALUE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(TextSensorStateRawTrigger),
}),
})
async def build_filters(config):
return await cg.build_registry_list(FILTER_REGISTRY, config)
async def setup_text_sensor_core_(var, config):
import esphome.config_validation as cv
from esphome import automation
from esphome.components import output
from esphome.const import CONF_ID, CONF_TYPE
from .. import template_ns
TemplateBinaryOutput = template_ns.class_('TemplateBinaryOutput', output.BinaryOutput)
TemplateFloatOutput = template_ns.class_('TemplateFloatOutput', output.FloatOutput)
CONF_BINARY = 'binary'
CONF_FLOAT = 'float'
CONF_WRITE_ACTION = 'write_action'
CONFIG_SCHEMA = cv.typed_schema({
CONF_BINARY: output.BINARY_OUTPUT_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(TemplateBinaryOutput),
cv.Required(CONF_WRITE_ACTION): automation.validate_automation(single=True),
}),
CONF_FLOAT: output.FLOAT_OUTPUT_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(TemplateFloatOutput),
cv.Required(CONF_WRITE_ACTION): automation.validate_automation(single=True),
}),
}, lower=True)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
if config[CONF_TYPE] == CONF_BINARY:
yield automation.build_automation(var.get_trigger(), [(bool, 'state')],
config[CONF_WRITE_ACTION])
else:
"4X": IIRFilter.IIR_FILTER_4,
"8X": IIRFilter.IIR_FILTER_8,
"16X": IIRFilter.IIR_FILTER_16,
"32X": IIRFilter.IIR_FILTER_32,
"64X": IIRFilter.IIR_FILTER_64,
"128X": IIRFilter.IIR_FILTER_128,
}
BMP3XXComponent = bmp3xx_ns.class_(
"BMP3XXComponent", cg.PollingComponent, i2c.I2CDevice
)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(BMP3XXComponent),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
).extend(
{
cv.Optional(CONF_OVERSAMPLING, default="2X"): cv.enum(
OVERSAMPLING_OPTIONS, upper=True
),
}
),
cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
unit_of_measurement=UNIT_HECTOPASCAL,
accuracy_decimals=1,
UNIT_MICROGRAMS_PER_CUBIC_METER, UNIT_COUNTS_PER_CUBIC_METER, UNIT_MICROMETER, \
ICON_CHEMICAL_WEAPON, ICON_COUNTER, ICON_RULER
DEPENDENCIES = ['i2c']
pmsa003i_ns = cg.esphome_ns.namespace('pmsa003i')
PMSA003IComponent = pmsa003i_ns.class_('PMSA003IComponent', cg.PollingComponent, i2c.I2CDevice)
CONF_STANDARD_UNITS = 'standard_units'
UNIT_COUNTS_PER_100ML = '#/0.1L'
CONF_PMC_0_3 = 'pmc_0_3'
CONF_PMC_5_0 = 'pmc_5_0'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(PMSA003IComponent),
cv.Optional(CONF_STANDARD_UNITS, default=True): cv.boolean,
cv.Optional(CONF_PM_1_0): sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON, 2),
cv.Optional(CONF_PM_2_5): sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON, 2),
cv.Optional(CONF_PM_10_0): sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON, 2),
cv.Optional(CONF_PMC_0_3): sensor.sensor_schema(UNIT_COUNTS_PER_100ML,
ICON_COUNTER, 2),
cv.Optional(CONF_PMC_0_5): sensor.sensor_schema(UNIT_COUNTS_PER_100ML,
ICON_COUNTER, 2),
cv.Optional(CONF_PMC_1_0): sensor.sensor_schema(UNIT_COUNTS_PER_100ML,
cv.string_strict,
cv.Optional(CONF_CERTIFICATE_AUTHORITY):
wpa2_eap.validate_certificate,
cv.Inclusive(CONF_CERTIFICATE, "certificate_and_key"):
wpa2_eap.validate_certificate,
# Only validate as file first because we need the password to load it
# Actual validation happens in validate_eap.
cv.Inclusive(CONF_KEY, "certificate_and_key"):
cv.file_,
}),
wpa2_eap.validate_eap,
cv.has_at_least_one_key(CONF_IDENTITY, CONF_CERTIFICATE),
)
WIFI_NETWORK_BASE = cv.Schema({
cv.GenerateID():
cv.declare_id(WiFiAP),
cv.Optional(CONF_SSID):
cv.ssid,
cv.Optional(CONF_PASSWORD):
validate_password,
cv.Optional(CONF_CHANNEL):
validate_channel,
cv.Optional(CONF_MANUAL_IP):
STA_MANUAL_IP_SCHEMA,
})
CONF_AP_TIMEOUT = "ap_timeout"
WIFI_NETWORK_AP = WIFI_NETWORK_BASE.extend({
cv.Optional(CONF_AP_TIMEOUT, default="1min"):
cv.positive_time_period_milliseconds,
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import spi, ssd1306_base
from esphome.const import CONF_DC_PIN, CONF_ID, CONF_LAMBDA, CONF_PAGES
AUTO_LOAD = ["ssd1306_base"]
DEPENDENCIES = ["spi"]
ssd1306_spi = cg.esphome_ns.namespace("ssd1306_spi")
SPISSD1306 = ssd1306_spi.class_("SPISSD1306", ssd1306_base.SSD1306, spi.SPIDevice)
CONFIG_SCHEMA = cv.All(
ssd1306_base.SSD1306_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(SPISSD1306),
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
}
)
.extend(cv.COMPONENT_SCHEMA)
.extend(spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await ssd1306_base.setup_ssd1036(var, config)
await spi.register_spi_device(var, config)
dc = await cg.gpio_pin_expression(config[CONF_DC_PIN])
