CONF_REFERENCE_VOLTAGE = 'reference_voltage'
CONF_CONFIGURATION = 'configuration'
CONF_RESISTOR = 'resistor'
ResistanceConfiguration = resistance_ns.enum('ResistanceConfiguration')
CONFIGURATIONS = {
'DOWNSTREAM': ResistanceConfiguration.DOWNSTREAM,
'UPSTREAM': ResistanceConfiguration.UPSTREAM,
}
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_OHM, ICON_FLASH, 1).extend({
cv.GenerateID(): cv.declare_id(ResistanceSensor),
cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
cv.Required(CONF_CONFIGURATION): cv.enum(CONFIGURATIONS, upper=True),
cv.Required(CONF_RESISTOR): cv.resistance,
cv.Optional(CONF_REFERENCE_VOLTAGE, default='3.3V'): cv.voltage,
}).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_SENSOR])
cg.add(var.set_sensor(sens))
cg.add(var.set_configuration(config[CONF_CONFIGURATION]))
cg.add(var.set_resistor(config[CONF_RESISTOR]))
cg.add(var.set_reference_voltage(config[CONF_REFERENCE_VOLTAGE]))
0: display_ns.DISPLAY_ROTATION_0_DEGREES,
90: display_ns.DISPLAY_ROTATION_90_DEGREES,
180: display_ns.DISPLAY_ROTATION_180_DEGREES,
270: display_ns.DISPLAY_ROTATION_270_DEGREES,
}
def validate_rotation(value):
value = cv.string(value)
if value.endswith("°"):
value = value[:-1]
return cv.enum(DISPLAY_ROTATIONS, int=True)(value)
BASIC_DISPLAY_SCHEMA = cv.Schema({
cv.Optional(CONF_LAMBDA): cv.lambda_,
})
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_id(DisplayPage),
cv.Required(CONF_LAMBDA): cv.lambda_,
}),
cv.Length(min=1),
),
cv.Optional(CONF_ON_PAGE_CHANGE):
automation.validate_automation({
)
DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_gcls002_ns = cg.esphome_ns.namespace("xiaomi_gcls002")
XiaomiGCLS002 = xiaomi_gcls002_ns.class_("XiaomiGCLS002",
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(XiaomiGCLS002),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(
UNIT_CELSIUS,
ICON_EMPTY,
1,
DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_MOISTURE):
sensor.sensor_schema(
UNIT_PERCENT,
ICON_WATER_PERCENT,
0,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
"global log level {}.".format(level, tag, global_level))
return value
Logger = logger_ns.class_("Logger", cg.Component)
LoggerMessageTrigger = logger_ns.class_(
"LoggerMessageTrigger",
automation.Trigger.template(cg.int_, cg.const_char_ptr, cg.const_char_ptr),
)
CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH = "esp8266_store_log_strings_in_flash"
CONFIG_SCHEMA = cv.All(
cv.Schema({
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,
cv.Optional(CONF_LEVEL, default="DEBUG"):
is_log_level,
cv.Optional(CONF_LOGS, default={}):
cv.Schema({
cv.string: is_log_level,
}),
cv.Optional(CONF_ON_MESSAGE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(LoggerMessageTrigger),
return value
def _parse_platform_version(value):
try:
# if platform version is a valid version constraint, prefix the default package
cv.platformio_version_constraint(value)
return f"platformio/espressif8266 @ {value}"
except cv.Invalid:
return value
CONF_PLATFORM_VERSION = "platform_version"
ARDUINO_FRAMEWORK_SCHEMA = cv.All(
cv.Schema({
cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
cv.Optional(CONF_SOURCE): cv.string_strict,
cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
}),
_arduino_check_versions,
)
BUILD_FLASH_MODES = ["qio", "qout", "dio", "dout"]
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.Required(CONF_BOARD):
cv.string_strict,
cv.Optional(CONF_FRAMEWORK, default={}):
ARDUINO_FRAMEWORK_SCHEMA,
cv.Optional(CONF_RESTORE_FROM_FLASH, default=False):
cv.boolean,
}
def validate(config):
if CONF_AQI in config and CONF_PM_2_5 not in config:
raise cv.Invalid("AQI sensor requires PM 2.5")
if CONF_AQI in config and CONF_PM_10_0 not in config:
raise cv.Invalid("AQI sensor requires PM 10 sensors")
return config
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID():
cv.declare_id(HM3301Component),
cv.Optional(CONF_PM_1_0):
sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON, 0),
cv.Optional(CONF_PM_2_5):
sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON, 0),
cv.Optional(CONF_PM_10_0):
sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON, 0),
cv.Optional(CONF_AQI):
sensor.sensor_schema(UNIT_INDEX, ICON_CHEMICAL_WEAPON, 0).extend({
cv.Required(CONF_CALCULATION_TYPE):
cv.enum(AQI_CALCULATION_TYPE, upper=True),
})
}).extend(cv.polling_component_schema('60s')).extend(
i2c.i2c_device_schema(0x40)), validate)
CONF_BINDKEY
CODEOWNERS = ['@vevsvevs']
DEPENDENCIES = ['esp32_ble_tracker']
AUTO_LOAD = ['xiaomi_ble']
xiaomi_mhoc401_ns = cg.esphome_ns.namespace('xiaomi_mhoc401')
XiaomiMHOC401 = xiaomi_mhoc401_ns.class_('XiaomiMHOC401',
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(XiaomiMHOC401),
cv.Required(CONF_BINDKEY): cv.bind_key,
cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
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_BATTERY_LEVEL): sensor.sensor_schema(UNIT_PERCENT, ICON_BATTERY, 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))
cg.add(var.set_bindkey(config[CONF_BINDKEY]))
if CONF_TEMPERATURE in config:
sens = yield sensor.new_sensor(config[CONF_TEMPERATURE])
"95KBPS": CanSpeed.CAN_95KBPS,
"100KBPS": CanSpeed.CAN_100KBPS,
"125KBPS": CanSpeed.CAN_125KBPS,
"200KBPS": CanSpeed.CAN_200KBPS,
"250KBPS": CanSpeed.CAN_250KBPS,
"500KBPS": CanSpeed.CAN_500KBPS,
"1000KBPS": CanSpeed.CAN_1000KBPS,
}
CANBUS_SCHEMA = cv.Schema(
{
cv.GenerateID():
cv.declare_id(CanbusComponent),
cv.Required(CONF_CAN_ID):
cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_BIT_RATE, default="125KBPS"):
cv.enum(CAN_SPEEDS, upper=True),
cv.Optional(CONF_USE_EXTENDED_ID, default=False):
cv.boolean,
cv.Optional(CONF_ON_FRAME):
automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(CanbusTrigger),
cv.Required(CONF_CAN_ID):
cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_CAN_ID_MASK, default=0x1FFFFFFF):
cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_USE_EXTENDED_ID, default=False):
cv.boolean,
},
DEPENDENCIES = ["i2c"]
scd4x_ns = cg.esphome_ns.namespace("scd4x")
SCD4XComponent = scd4x_ns.class_("SCD4XComponent", cg.PollingComponent, i2c.I2CDevice)
CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
CONF_TEMPERATURE_OFFSET = "temperature_offset"
CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE = "ambient_pressure_compensation_source"
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(SCD4XComponent),
cv.Optional(CONF_CO2): sensor.sensor_schema(
unit_of_measurement=UNIT_PARTS_PER_MILLION,
icon=ICON_MOLECULE_CO2,
accuracy_decimals=0,
device_class=DEVICE_CLASS_CARBON_DIOXIDE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
icon=ICON_THERMOMETER,
accuracy_decimals=2,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
CalibrateLinearFilter = sensor_ns.class_("CalibrateLinearFilter", Filter)
CalibratePolynomialFilter = sensor_ns.class_("CalibratePolynomialFilter",
Filter)
SensorInRangeCondition = sensor_ns.class_("SensorInRangeCondition", Filter)
unit_of_measurement = cv.string_strict
accuracy_decimals = cv.int_
icon = cv.icon
device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
cv.OnlyWith(CONF_MQTT_ID, "mqtt"):
cv.declare_id(mqtt.MQTTSensorComponent),
cv.GenerateID():
cv.declare_id(Sensor),
cv.Optional(CONF_UNIT_OF_MEASUREMENT):
unit_of_measurement,
cv.Optional(CONF_ICON):
icon,
cv.Optional(CONF_ACCURACY_DECIMALS):
accuracy_decimals,
cv.Optional(CONF_DEVICE_CLASS):
device_class,
cv.Optional(CONF_STATE_CLASS):
validate_state_class,
cv.Optional(CONF_FORCE_UPDATE, default=False):
cv.boolean,
cv.Optional(CONF_EXPIRE_AFTER):
cv.All(
cv.requires_component("mqtt"),
cv.Any(None, cv.positive_time_period_milliseconds),
DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_lywsd03mmc_ns = cg.esphome_ns.namespace("xiaomi_lywsd03mmc")
XiaomiLYWSD03MMC = xiaomi_lywsd03mmc_ns.class_(
"XiaomiLYWSD03MMC", esp32_ble_tracker.ESPBTDeviceListener, cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(XiaomiLYWSD03MMC),
cv.Required(CONF_BINDKEY):
cv.bind_key,
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
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,
),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_BATTERY_LEVEL):
sensor.sensor_schema(
CONF_CHARGE_MODE = "charge_mode"
CONF_INPUT_VOLTAGE = "input_voltage"
CONF_BATTERY_VOLTAGE = "battery_voltage"
CONF_CHARGING_CURRENT = "charging_current"
CONF_LOAD_VOLTAGE = "load_voltage"
CONF_LOAD_CURRENT = "load_current"
CONF_CHARGING_POWER = "charging_power"
CONF_LOAD_POWER = "load_power"
CONF_BATTERY_TEMP = "battery_temp"
CONF_INTERNAL_TEMP = "internal_temp"
CONF_BATTERY_LEVEL = "battery_level"
CONFIG_SCHEMA = uart.UART_DEVICE_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(ESmart3Component),
cv.Optional(CONF_CHARGE_MODE): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0),
cv.Optional(CONF_INPUT_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
cv.Optional(CONF_CHARGING_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_CURRENT_AC, 1),
cv.Optional(CONF_LOAD_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
cv.Optional(CONF_LOAD_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_CURRENT_AC, 1),
cv.Optional(CONF_CHARGING_POWER): sensor.sensor_schema(UNIT_WATT, ICON_POWER, 0),
cv.Optional(CONF_LOAD_POWER): sensor.sensor_schema(UNIT_WATT, ICON_POWER, 0),
cv.Optional(CONF_BATTERY_TEMP): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 0),
cv.Optional(CONF_INTERNAL_TEMP): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 0),
cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(UNIT_PERCENT, ICON_PERCENT, 0),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
}
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),
cv.Optional(CONF_VALUE_FONT):
def inherit_accuracy_decimals(decimals, config):
return decimals + 2
CONFIG_SCHEMA = (sensor.sensor_schema(
TotalDailyEnergy,
device_class=DEVICE_CLASS_ENERGY,
state_class=STATE_CLASS_TOTAL_INCREASING,
).extend({
cv.GenerateID(CONF_TIME_ID):
cv.use_id(time.RealTimeClock),
cv.Required(CONF_POWER_ID):
cv.use_id(sensor.Sensor),
cv.Optional(CONF_RESTORE, default=True):
cv.boolean,
cv.Optional("min_save_interval"):
cv.invalid(
"`min_save_interval` was removed in 2022.6.0. Please use the `preferences` -> `flash_write_interval` to adjust."
),
cv.Optional(CONF_METHOD, default="right"):
cv.enum(TOTAL_DAILY_ENERGY_METHODS, lower=True),
}).extend(cv.COMPONENT_SCHEMA))
FINAL_VALIDATE_SCHEMA = cv.All(
cv.Schema(
{
cv.Required(CONF_ID): cv.use_id(TotalDailyEnergy),
cv.Optional(CONF_ICON): cv.icon,
cv.Optional(CONF_UNIT_OF_MEASUREMENT):
mcp23S17_ns = cg.esphome_ns.namespace('mcp23s17')
mcp23S17GPIOMode = mcp23S17_ns.enum('MCP23S17GPIOMode')
mcp23S17_GPIO_MODES = {
'INPUT': mcp23S17GPIOMode.MCP23S17_INPUT,
'INPUT_PULLUP': mcp23S17GPIOMode.MCP23S17_INPUT_PULLUP,
'OUTPUT': mcp23S17GPIOMode.MCP23S17_OUTPUT,
}
mcp23S17 = mcp23S17_ns.class_('MCP23S17', cg.Component, spi.SPIDevice)
mcp23S17GPIOPin = mcp23S17_ns.class_('MCP23S17GPIOPin', cg.GPIOPin)
CONFIG_SCHEMA = cv.Schema({
cv.Required(CONF_ID):
cv.declare_id(mcp23S17),
cv.Optional(CONF_DEVICEADDRESS, default=0):
cv.uint8_t,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema())
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
cg.add(var.set_device_address(config[CONF_DEVICEADDRESS]))
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
CONF_MCP23S17 = 'mcp23s17'
mcp23S17_OUTPUT_PIN_SCHEMA = cv.Schema({
cv.GenerateID(CONF_MCP23S17):
"WS2803",
"SM16716",
"P9813",
"APA102",
"SK9822",
"DOTSTAR",
]
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,
cv.Optional(CONF_DATA_RATE):
cv.frequency,
})
def to_code(config):
var = yield fastled_base.new_fastled_light(config)
rgb_order = cg.RawExpression(config[CONF_RGB_ORDER] if CONF_RGB_ORDER in
config else "RGB")
data_rate = None
if CONF_DATA_RATE in config:
data_rate_khz = int(config[CONF_DATA_RATE] / 1000)
if data_rate_khz < 1000:
data_rate = cg.RawExpression(f"DATA_RATE_KHZ({data_rate_khz})")
)
DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_lywsdcgq_ns = cg.esphome_ns.namespace("xiaomi_lywsdcgq")
XiaomiLYWSDCGQ = xiaomi_lywsdcgq_ns.class_(
"XiaomiLYWSDCGQ", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(XiaomiLYWSDCGQ),
cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
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,
),
cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
accuracy_decimals=1,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_BATTERY,
def _validate(config):
if CONF_WAVE_CHANNEL_ID in config and CONF_COMPONENT_ID not in config:
raise cv.Invalid(
f"{CONF_COMPONENT_ID} is required when {CONF_WAVE_CHANNEL_ID} is set"
)
return config
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(accuracy_decimals=2, ).extend({
cv.GenerateID():
cv.declare_id(NextionSensor),
cv.Optional(CONF_PRECISION, default=0):
cv.int_range(min=0, max=8),
cv.Optional(CONF_WAVE_CHANNEL_ID):
CheckWaveID,
cv.Optional(CONF_COMPONENT_ID):
cv.uint8_t,
cv.Optional(CONF_WAVE_MAX_LENGTH, default=255):
cv.int_range(min=1, max=1024),
cv.Optional(CONF_WAVE_MAX_VALUE, default=100):
cv.int_range(min=1, max=1024),
cv.Optional(CONF_WAVEFORM_SEND_LAST_VALUE, default=True):
cv.boolean,
}).extend(CONFIG_SENSOR_COMPONENT_SCHEMA).extend(
cv.polling_component_schema("never")),
cv.has_exactly_one_key(CONF_COMPONENT_ID, CONF_COMPONENT_NAME,
CONF_VARIABLE_NAME),
CONF_LEVEL,
CONF_MAX_POWER,
CONF_MIN_POWER,
CONF_POWER_SUPPLY,
)
from esphome.core import CORE
CODEOWNERS = ["@esphome/core"]
IS_PLATFORM_COMPONENT = True
CONF_ZERO_MEANS_ZERO = "zero_means_zero"
BINARY_OUTPUT_SCHEMA = cv.Schema(
{
cv.Optional(CONF_POWER_SUPPLY): cv.use_id(power_supply.PowerSupply),
cv.Optional(CONF_INVERTED): cv.boolean,
}
)
FLOAT_OUTPUT_SCHEMA = BINARY_OUTPUT_SCHEMA.extend(
{
cv.Optional(CONF_MAX_POWER): cv.percentage,
cv.Optional(CONF_MIN_POWER): cv.percentage,
cv.Optional(CONF_ZERO_MEANS_ZERO, default=False): cv.boolean,
}
)
output_ns = cg.esphome_ns.namespace("output")
BinaryOutput = output_ns.class_("BinaryOutput")
BinaryOutputPtr = BinaryOutput.operator("ptr")
e131_ns = cg.esphome_ns.namespace('e131')
E131AddressableLightEffect = e131_ns.class_('E131AddressableLightEffect',
AddressableLightEffect)
E131Component = e131_ns.class_('E131Component', cg.Component)
METHODS = {'UNICAST': 'E131_UNICAST', 'MULTICAST': 'E131_MULTICAST'}
CHANNELS = {'MONO': 'E131_MONO', 'RGB': 'E131_RGB', 'RGBW': 'E131_RGBW'}
CONF_UNIVERSE = 'universe'
CONF_E131_ID = 'e131_id'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(E131Component),
cv.Optional(CONF_METHOD, default='MULTICAST'):
cv.one_of(*METHODS, upper=True),
})
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(var.set_method(getattr(cg.global_ns, METHODS[config[CONF_METHOD]])))
def register_addressable_effect(name, effect_type, default_name, schema,
*extra_validators):
ADDRESSABLE_EFFECTS.append(name)
return register_effect(name, effect_type, default_name, schema,
*extra_validators)
import esphome.config_validation as cv
from esphome.components import sensor, voltage_sampler
from esphome.const import CONF_SENSOR, CONF_ID, ICON_FLASH, UNIT_AMPERE
AUTO_LOAD = ['voltage_sampler']
CONF_SAMPLE_DURATION = 'sample_duration'
ct_clamp_ns = cg.esphome_ns.namespace('ct_clamp')
CTClampSensor = ct_clamp_ns.class_('CTClampSensor', sensor.Sensor,
cg.PollingComponent)
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2).extend({
cv.GenerateID():
cv.declare_id(CTClampSensor),
cv.Required(CONF_SENSOR):
cv.use_id(voltage_sampler.VoltageSampler),
cv.Optional(CONF_SAMPLE_DURATION, default='200ms'):
cv.positive_time_period_milliseconds,
}).extend(cv.polling_component_schema('60s'))
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_SENSOR])
cg.add(var.set_source(sens))
cg.add(var.set_sample_duration(config[CONF_SAMPLE_DURATION]))
wifi_info_ns = cg.esphome_ns.namespace("wifi_info")
IPAddressWiFiInfo = wifi_info_ns.class_("IPAddressWiFiInfo",
text_sensor.TextSensor,
cg.PollingComponent)
ScanResultsWiFiInfo = wifi_info_ns.class_("ScanResultsWiFiInfo",
text_sensor.TextSensor,
cg.PollingComponent)
SSIDWiFiInfo = wifi_info_ns.class_("SSIDWiFiInfo", text_sensor.TextSensor,
cg.PollingComponent)
BSSIDWiFiInfo = wifi_info_ns.class_("BSSIDWiFiInfo", text_sensor.TextSensor,
cg.PollingComponent)
MacAddressWifiInfo = wifi_info_ns.class_("MacAddressWifiInfo",
text_sensor.TextSensor, cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.Optional(CONF_IP_ADDRESS):
text_sensor.text_sensor_schema(
klass=IPAddressWiFiInfo,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
cv.Optional(CONF_SCAN_RESULTS):
text_sensor.text_sensor_schema(
klass=ScanResultsWiFiInfo,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("60s")),
cv.Optional(CONF_SSID):
text_sensor.text_sensor_schema(
klass=SSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
cv.Optional(CONF_BSSID):
text_sensor.text_sensor_schema(
from .. import mqtt_subscribe_ns
DEPENDENCIES = ["mqtt"]
CONF_MQTT_PARENT_ID = "mqtt_parent_id"
MQTTSubscribeTextSensor = mqtt_subscribe_ns.class_("MQTTSubscribeTextSensor",
text_sensor.TextSensor,
cg.Component)
CONFIG_SCHEMA = text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(MQTTSubscribeTextSensor),
cv.GenerateID(CONF_MQTT_PARENT_ID):
cv.use_id(mqtt.MQTTClientComponent),
cv.Required(CONF_TOPIC):
cv.subscribe_topic,
cv.Optional(CONF_QOS, default=0):
cv.mqtt_qos,
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield text_sensor.register_text_sensor(var, config)
parent = yield cg.get_variable(config[CONF_MQTT_PARENT_ID])
cg.add(var.set_parent(parent))
cg.add(var.set_topic(config[CONF_TOPIC]))
cg.add(var.set_qos(config[CONF_QOS]))
ST7735Model = st7735_ns.enum("ST7735Model")
MODELS = {
"INITR_GREENTAB": ST7735Model.ST7735_INITR_GREENTAB,
"INITR_REDTAB": ST7735Model.ST7735_INITR_REDTAB,
"INITR_BLACKTAB": ST7735Model.ST7735_INITR_BLACKTAB,
"INITR_MINI160X80": ST7735Model.ST7735_INITR_MINI_160X80,
"INITR_18BLACKTAB": ST7735Model.ST7735_INITR_18BLACKTAB,
"INITR_18REDTAB": ST7735Model.ST7735_INITR_18REDTAB,
}
ST7735_MODEL = cv.enum(MODELS, upper=True, space="_")
ST7735_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.Required(CONF_MODEL):
ST7735_MODEL,
cv.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.polling_component_schema("1s"))
CONFIG_SCHEMA = cv.All(
ST7735_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(SPIST7735),
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_DEVICE_WIDTH): cv.int_,
cv.Required(CONF_DEVICE_HEIGHT): cv.int_,
cv.Required(CONF_COL_START): cv.int_,
cv.Required(CONF_ROW_START): cv.int_,
cv.Optional(CONF_EIGHT_BIT_COLOR, default=False): cv.boolean,
cv.Optional(CONF_USE_BGR, default=False): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
DEPENDENCIES = ['esp32_ble_tracker']
AUTO_LOAD = ['xiaomi_ble']
xiaomi_mue4094rt_ns = cg.esphome_ns.namespace('xiaomi_mue4094rt')
XiaomiMUE4094RT = xiaomi_mue4094rt_ns.class_(
'XiaomiMUE4094RT', binary_sensor.BinarySensor, cg.Component,
esp32_ble_tracker.ESPBTDeviceListener)
CONFIG_SCHEMA = cv.All(
binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(XiaomiMUE4094RT),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_DEVICE_CLASS, default='motion'):
binary_sensor.device_class,
cv.Optional(CONF_TIMEOUT, default='5s'):
cv.positive_time_period_milliseconds,
}).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)
yield binary_sensor.register_binary_sensor(var, config)
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
cg.add(var.set_time(config[CONF_TIMEOUT]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import (CONF_ID, CONF_NUM_ATTEMPTS, CONF_PASSWORD,
CONF_PORT, CONF_REBOOT_TIMEOUT, CONF_SAFE_MODE)
from esphome.core import CORE, coroutine_with_priority
CODEOWNERS = ['@esphome/core']
DEPENDENCIES = ['network']
ota_ns = cg.esphome_ns.namespace('ota')
OTAComponent = ota_ns.class_('OTAComponent', cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(OTAComponent),
cv.Optional(CONF_SAFE_MODE, default=True):
cv.boolean,
cv.SplitDefault(CONF_PORT, esp8266=8266, esp32=3232):
cv.port,
cv.Optional(CONF_PASSWORD, default=''):
cv.string,
cv.Optional(CONF_REBOOT_TIMEOUT, default='5min'):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_NUM_ATTEMPTS, default='10'):
cv.positive_not_null_int
}).extend(cv.COMPONENT_SCHEMA)
@coroutine_with_priority(50.0)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
from . import DallasComponent, dallas_ns
DallasTemperatureSensor = dallas_ns.class_("DallasTemperatureSensor",
sensor.Sensor)
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(
DallasTemperatureSensor,
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
).extend({
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])
var = await sensor.new_sensor(config)
if CONF_ADDRESS in config:
)
CODEOWNERS = ["@senexcrenshaw"]
DEPENDENCIES = ["uart"]
AUTO_LOAD = ["binary_sensor", "switch", "sensor", "text_sensor"]
SetupTrigger = nextion_ns.class_("SetupTrigger", automation.Trigger.template())
SleepTrigger = nextion_ns.class_("SleepTrigger", automation.Trigger.template())
WakeTrigger = nextion_ns.class_("WakeTrigger", automation.Trigger.template())
PageTrigger = nextion_ns.class_("PageTrigger", automation.Trigger.template())
CONFIG_SCHEMA = (display.BASIC_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(Nextion),
cv.Optional(CONF_TFT_URL):
cv.All(cv.string, cv.only_with_arduino),
cv.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
cv.Optional(CONF_ON_SETUP):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(SetupTrigger),
}),
cv.Optional(CONF_ON_SLEEP):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(SleepTrigger),
}),
cv.Optional(CONF_ON_WAKE):
automation.validate_automation({
CODEOWNERS = ["@rbaron"]
DEPENDENCIES = ["esp32_ble_tracker"]
b_parasite_ns = cg.esphome_ns.namespace("b_parasite")
BParasite = b_parasite_ns.class_("BParasite",
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(BParasite),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
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,
),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
accuracy_decimals=1,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_BATTERY_VOLTAGE):
sensor.sensor_schema(
DeltaFilter = sensor_ns.class_("DeltaFilter", Filter)
OrFilter = sensor_ns.class_("OrFilter", Filter)
CalibrateLinearFilter = sensor_ns.class_("CalibrateLinearFilter", Filter)
CalibratePolynomialFilter = sensor_ns.class_("CalibratePolynomialFilter", Filter)
SensorInRangeCondition = sensor_ns.class_("SensorInRangeCondition", Filter)
validate_unit_of_measurement = cv.string_strict
validate_accuracy_decimals = cv.int_
validate_icon = cv.icon
validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).extend(
{
cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSensorComponent),
cv.GenerateID(): cv.declare_id(Sensor),
cv.Optional(CONF_UNIT_OF_MEASUREMENT): validate_unit_of_measurement,
cv.Optional(CONF_ACCURACY_DECIMALS): validate_accuracy_decimals,
cv.Optional(CONF_DEVICE_CLASS): validate_device_class,
cv.Optional(CONF_STATE_CLASS): validate_state_class,
cv.Optional("last_reset_type"): cv.invalid(
"last_reset_type has been removed since 2021.9.0. state_class: total_increasing should be used for total values."
),
cv.Optional(CONF_FORCE_UPDATE, default=False): cv.boolean,
cv.Optional(CONF_EXPIRE_AFTER): cv.All(
cv.requires_component("mqtt"),
cv.Any(None, cv.positive_time_period_milliseconds),
),
cv.Optional(CONF_FILTERS): validate_filters,
cv.Optional(CONF_ON_VALUE): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SensorStateTrigger),
