import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import display, uart from esphome.const import CONF_ID, CONF_LAMBDA, CONF_BRIGHTNESS from . import nextion_ns DEPENDENCIES = ["uart"] AUTO_LOAD = ["binary_sensor"] Nextion = nextion_ns.class_("Nextion", cg.PollingComponent, uart.UARTDevice) NextionRef = Nextion.operator("ref") CONFIG_SCHEMA = (display.BASIC_DISPLAY_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(Nextion), cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage, }).extend(cv.polling_component_schema("5s")).extend(uart.UART_DEVICE_SCHEMA)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await uart.register_uart_device(var, config) if CONF_BRIGHTNESS in config: cg.add(var.set_brightness(config[CONF_BRIGHTNESS])) if CONF_LAMBDA in config: lambda_ = await cg.process_lambda(config[CONF_LAMBDA], [(NextionRef, "it")], return_type=cg.void)
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c, sensor from esphome.const import CONF_ID, DEVICE_CLASS_TEMPERATURE, ICON_EMPTY, UNIT_CELSIUS DEPENDENCIES = ["i2c"] sts3x_ns = cg.esphome_ns.namespace("sts3x") STS3XComponent = sts3x_ns.class_("STS3XComponent", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (sensor.sensor_schema( UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE).extend({ cv.GenerateID(): cv.declare_id(STS3XComponent), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x4A))) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await sensor.register_sensor(var, config) await i2c.register_i2c_device(var, 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, cv.Required(CONF_NUM_LEDS):
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])
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), ), )
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 light, output from esphome.const import CONF_OUTPUT_ID, CONF_PIN_A, CONF_PIN_B hbridge_ns = cg.esphome_ns.namespace("hbridge") HBridgeLightOutput = hbridge_ns.class_("HBridgeLightOutput", cg.PollingComponent, light.LightOutput) CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({ cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(HBridgeLightOutput), cv.Required(CONF_PIN_A): cv.use_id(output.FloatOutput), cv.Required(CONF_PIN_B): cv.use_id(output.FloatOutput), }) def to_code(config): var = cg.new_Pvariable(config[CONF_OUTPUT_ID]) yield cg.register_component(var, config) yield light.register_light(var, config) hside = yield cg.get_variable(config[CONF_PIN_A]) cg.add(var.set_pina_pin(hside)) lside = yield cg.get_variable(config[CONF_PIN_B]) cg.add(var.set_pinb_pin(lside))
import esphome.codegen as cg import esphome.config_validation as cv from esphome import pins from esphome.components import sensor from esphome.const import CONF_ECHO_PIN, CONF_ID, CONF_TRIGGER_PIN, \ CONF_TIMEOUT, UNIT_METER, ICON_ARROW_EXPAND_VERTICAL CONF_PULSE_TIME = 'pulse_time' ultrasonic_ns = cg.esphome_ns.namespace('ultrasonic') UltrasonicSensorComponent = ultrasonic_ns.class_('UltrasonicSensorComponent', sensor.Sensor, cg.PollingComponent) CONFIG_SCHEMA = sensor.sensor_schema(UNIT_METER, ICON_ARROW_EXPAND_VERTICAL, 2).extend({ cv.GenerateID(): cv.declare_id(UltrasonicSensorComponent), cv.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema, cv.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema, cv.Optional(CONF_TIMEOUT, default='2m'): cv.distance, cv.Optional(CONF_PULSE_TIME, default='10us'): cv.positive_time_period_microseconds, cv.Optional('timeout_meter'): cv.invalid("The timeout_meter option has been renamed " "to 'timeout' in 1.12."), cv.Optional('timeout_time'): cv.invalid("The timeout_time option has been removed. Please " "use 'timeout' in 1.12."), }).extend(cv.polling_component_schema('60s')) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config)
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c from esphome.components import light from esphome.const import CONF_OUTPUT_ID DEPENDENCIES = ['i2c'] lp5024_ns = cg.esphome_ns.namespace('lp5024') LP5024LightOutputBase = lp5024_ns.class_('LP5024LightOutputBase', light.AddressableLight) CONFIG_SCHEMA = cv.All( light.ADDRESSABLE_LIGHT_SCHEMA.extend({ cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(LP5024LightOutputBase), }).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x50))) def to_code(config): var = cg.new_Pvariable(config[CONF_OUTPUT_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config) yield light.register_light(var, config)
import esphome.codegen as cg import esphome.config_validation as cv from esphome import pins from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_SCAN, CONF_SCL, CONF_SDA, CONF_ADDRESS, \ CONF_I2C_ID from esphome.core import coroutine, coroutine_with_priority i2c_ns = cg.esphome_ns.namespace('i2c') I2CComponent = i2c_ns.class_('I2CComponent', cg.Component) I2CDevice = i2c_ns.class_('I2CDevice') MULTI_CONF = True CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(I2CComponent), cv.Optional(CONF_SDA, default='SDA'): pins.input_pin, cv.Optional(CONF_SCL, default='SCL'): pins.input_pin, cv.Optional(CONF_FREQUENCY, default='50kHz'): cv.All(cv.frequency, cv.Range(min=0, min_included=False)), cv.Optional(CONF_SCAN, default=True): cv.boolean, }).extend(cv.COMPONENT_SCHEMA) @coroutine_with_priority(1.0) def to_code(config): cg.add_global(i2c_ns.using) var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config)
import esphome.config_validation as cv from esphome.components import sensor from esphome.const import ( CONF_ID, DEVICE_CLASS_SIGNAL_STRENGTH, ENTITY_CATEGORY_DIAGNOSTIC, STATE_CLASS_MEASUREMENT, UNIT_DECIBEL_MILLIWATT, ) DEPENDENCIES = ["wifi"] wifi_signal_ns = cg.esphome_ns.namespace("wifi_signal") WiFiSignalSensor = wifi_signal_ns.class_("WiFiSignalSensor", sensor.Sensor, cg.PollingComponent) CONFIG_SCHEMA = (sensor.sensor_schema( unit_of_measurement=UNIT_DECIBEL_MILLIWATT, accuracy_decimals=0, device_class=DEVICE_CLASS_SIGNAL_STRENGTH, state_class=STATE_CLASS_MEASUREMENT, entity_category=ENTITY_CATEGORY_DIAGNOSTIC, ).extend({ cv.GenerateID(): cv.declare_id(WiFiSignalSensor), }).extend(cv.polling_component_schema("60s"))) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await sensor.register_sensor(var, config)
UNIT_CELSIUS, ICON_PERCENT, ICON_THERMOMETER, DEVICE_CLASS_BATTERY, DEVICE_CLASS_TEMPERATURE, ) AUTO_LOAD = ['sensor'] CONF_CURRENT_TEMP = "current_temp" CONF_STATE_CLASS = "measurement" WavinAhc9000Climate = wavinAhc9000_ns.class_('WavinAhc9000Climate', climate.Climate, cg.Component) CONFIG_SCHEMA = climate.CLIMATE_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(WavinAhc9000Climate), cv.GenerateID(CONF_WAVINAHC9000_ID): cv.use_id(WavinAhc9000), cv.Required(CONF_CHANNEL): cv.int_range(min=1, max=16), cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(UNIT_PERCENT, ICON_PERCENT, 0, DEVICE_CLASS_BATTERY), cv.Optional(CONF_CURRENT_TEMP): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1, DEVICE_CLASS_TEMPERATURE, CONF_STATE_CLASS), }).extend(cv.COMPONENT_SCHEMA) def to_code(config): wavin = yield cg.get_variable(config[CONF_WAVINAHC9000_ID]) var = cg.new_Pvariable(config[CONF_ID], wavin) yield cg.register_component(var, config) yield climate.register_climate(var, config) cg.add(var.set_channel(config[CONF_CHANNEL] - 1)) if CONF_BATTERY_LEVEL in config: sens = yield sensor.new_sensor(config[CONF_BATTERY_LEVEL])
UNIT_PERCENT, UNIT_EMPTY, ) DEPENDENCIES = ["i2c"] # locally defined constant lc709203f_ns = cg.esphome_ns.namespace("lc709203f") LC709203FComponent = lc709203f_ns.class_("LC709203FComponent", cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(LC709203FComponent), cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 2).extend({}), cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 1).extend({}), cv.Optional("cell_charge"): sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 0).extend({}), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x77))) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config)
} color_channel_schema = sensor.sensor_schema( UNIT_PERCENT, ICON_LIGHTBULB, 1, DEVICE_CLASS_EMPTY ) color_temperature_schema = sensor.sensor_schema( UNIT_KELVIN, ICON_THERMOMETER, 1, DEVICE_CLASS_EMPTY ) illuminance_schema = sensor.sensor_schema( UNIT_LUX, ICON_EMPTY, 1, DEVICE_CLASS_ILLUMINANCE ) 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="2.4ms"): cv.enum( TCS34725_INTEGRATION_TIMES, lower=True ), cv.Optional(CONF_GAIN, default="1X"): cv.enum(TCS34725_GAINS, upper=True), } ) .extend(cv.polling_component_schema("60s")) .extend(i2c.i2c_device_schema(0x29)) )
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])
CODEOWNERS = ["@esphome/core"] IS_PLATFORM_COMPONENT = True LightRestoreMode = light_ns.enum("LightRestoreMode") RESTORE_MODES = { "RESTORE_DEFAULT_OFF": LightRestoreMode.LIGHT_RESTORE_DEFAULT_OFF, "RESTORE_DEFAULT_ON": LightRestoreMode.LIGHT_RESTORE_DEFAULT_ON, "ALWAYS_OFF": LightRestoreMode.LIGHT_ALWAYS_OFF, "ALWAYS_ON": LightRestoreMode.LIGHT_ALWAYS_ON, "RESTORE_INVERTED_DEFAULT_OFF": LightRestoreMode.LIGHT_RESTORE_INVERTED_DEFAULT_OFF, "RESTORE_INVERTED_DEFAULT_ON": LightRestoreMode.LIGHT_RESTORE_INVERTED_DEFAULT_ON, } LIGHT_SCHEMA = cv.NAMEABLE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend( { cv.GenerateID(): cv.declare_id(LightState), cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTJSONLightComponent), cv.Optional(CONF_RESTORE_MODE, default="restore_default_off"): cv.enum( RESTORE_MODES, upper=True, space="_" ), cv.Optional(CONF_ON_TURN_ON): auto.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LightTurnOnTrigger), } ), cv.Optional(CONF_ON_TURN_OFF): auto.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LightTurnOffTrigger), } ), }
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):
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import switch from esphome.const import CONF_ID, CONF_LAMBDA, CONF_SWITCHES from .. import custom_ns CustomSwitchConstructor = custom_ns.class_("CustomSwitchConstructor") CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(CustomSwitchConstructor), cv.Required(CONF_LAMBDA): cv.returning_lambda, cv.Required(CONF_SWITCHES): cv.ensure_list( switch.SWITCH_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(switch.Switch), })), }) async def to_code(config): template_ = await cg.process_lambda(config[CONF_LAMBDA], [], return_type=cg.std_vector.template( switch.SwitchPtr)) rhs = CustomSwitchConstructor(template_) var = cg.variable(config[CONF_ID], rhs) for i, conf in enumerate(config[CONF_SWITCHES]): switch_ = cg.Pvariable(conf[CONF_ID], var.get_switch(i))
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import binary_sensor from esphome.const import CONF_ID, CONF_DEVICE_CLASS, DEVICE_CLASS_CONNECTIVITY status_ns = cg.esphome_ns.namespace("status") StatusBinarySensor = status_ns.class_("StatusBinarySensor", binary_sensor.BinarySensor, cg.Component) CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(StatusBinarySensor), cv.Optional(CONF_DEVICE_CLASS, default=DEVICE_CLASS_CONNECTIVITY): binary_sensor.device_class, }).extend(cv.COMPONENT_SCHEMA) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield binary_sensor.register_binary_sensor(var, config)
from esphome.const import CONF_ID, CONF_SENSOR AUTO_LOAD = ['sensor'] yashima_ns = cg.esphome_ns.namespace('yashima') YashimaClimate = yashima_ns.class_('YashimaClimate', climate.Climate, cg.Component) CONF_TRANSMITTER_ID = 'transmitter_id' CONF_SUPPORTS_HEAT = 'supports_heat' CONF_SUPPORTS_COOL = 'supports_cool' CONFIG_SCHEMA = cv.All( climate.CLIMATE_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(YashimaClimate), cv.GenerateID(CONF_TRANSMITTER_ID): cv.use_id(remote_transmitter.RemoteTransmitterComponent), cv.Optional(CONF_SUPPORTS_COOL, default=True): cv.boolean, cv.Optional(CONF_SUPPORTS_HEAT, default=True): cv.boolean, cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor), }).extend(cv.COMPONENT_SCHEMA)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield climate.register_climate(var, config)
def validate_full_update_every_only_type_a(value): if CONF_FULL_UPDATE_EVERY not in value: return value if MODELS[value[CONF_MODEL]][0] == "b": raise cv.Invalid( "The 'full_update_every' option is only available for models " "'1.54in', '1.54inV2', '2.13in', '2.90in', and '2.90inV2'.") return value CONFIG_SCHEMA = cv.All( display.FULL_DISPLAY_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(WaveshareEPaper), cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema, cv.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True), cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema, cv.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema, cv.Optional(CONF_FULL_UPDATE_EVERY): cv.uint32_t, }).extend(cv.polling_component_schema("1s")).extend( spi.spi_device_schema()), validate_full_update_every_only_type_a, cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA), )
CONF_DOUT_PIN = "dout_pin" HX711Gain = hx711_ns.enum("HX711Gain") GAINS = { 128: HX711Gain.HX711_GAIN_128, 32: HX711Gain.HX711_GAIN_32, 64: HX711Gain.HX711_GAIN_64, } CONFIG_SCHEMA = (sensor.sensor_schema( icon=ICON_SCALE, accuracy_decimals=0, state_class=STATE_CLASS_MEASUREMENT, ).extend({ cv.GenerateID(): cv.declare_id(HX711Sensor), cv.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema, cv.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema, cv.Optional(CONF_GAIN, default=128): cv.enum(GAINS, int=True), }).extend(cv.polling_component_schema("60s"))) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await sensor.register_sensor(var, config) dout_pin = await cg.gpio_pin_expression(config[CONF_DOUT_PIN]) cg.add(var.set_dout_pin(dout_pin)) sck_pin = await cg.gpio_pin_expression(config[CONF_CLK_PIN]) cg.add(var.set_sck_pin(sck_pin))
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,
UNIT_CELSIUS, UNIT_PERCENT, UNIT_VOLT, ) CODEOWNERS = ["@ahpohl"] DEPENDENCIES = ["esp32_ble_tracker"] atc_mithermometer_ns = cg.esphome_ns.namespace("atc_mithermometer") ATCMiThermometer = atc_mithermometer_ns.class_( "ATCMiThermometer", esp32_ble_tracker.ESPBTDeviceListener, cg.Component) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(ATCMiThermometer), 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,
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"))
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import sensor, modbus from esphome.const import CONF_CURRENT, CONF_ID, CONF_POWER, CONF_VOLTAGE, \ CONF_FREQUENCY, UNIT_VOLT, ICON_FLASH, UNIT_AMPERE, UNIT_WATT, UNIT_EMPTY, \ ICON_POWER, CONF_POWER_FACTOR, ICON_CURRENT_AC, UNIT_HERTZ, \ CONF_ENERGY, UNIT_WATT_HOURS, ICON_COUNTER AUTO_LOAD = ['modbus'] nilanac_ns = cg.esphome_ns.namespace('nilan') NILAN = nilanac_ns.class_('NILAN', cg.PollingComponent, modbus.ModbusDevice) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(NILAN), cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1), cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_CURRENT_AC, 3), cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_POWER, 1), cv.Optional(CONF_ENERGY): sensor.sensor_schema(UNIT_WATT_HOURS, ICON_COUNTER, 0), cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(UNIT_HERTZ, ICON_CURRENT_AC, 1), cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(UNIT_EMPTY, ICON_FLASH, 2), }).extend(cv.polling_component_schema('60s')).extend( modbus.modbus_device_schema(0x30))
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]) await text_sensor.register_text_sensor(sens, conf) cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
UNIT_PERCENT, CONF_BINDKEY, ) DEPENDENCIES = ["esp32_ble_tracker"] AUTO_LOAD = ["xiaomi_ble"] xiaomi_cgd1_ns = cg.esphome_ns.namespace("xiaomi_cgd1") XiaomiCGD1 = xiaomi_cgd1_ns.class_( "XiaomiCGD1", esp32_ble_tracker.ESPBTDeviceListener, cg.Component ) CONFIG_SCHEMA = ( cv.Schema( { cv.GenerateID(): cv.declare_id(XiaomiCGD1), 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_EMPTY, 1, DEVICE_CLASS_TEMPERATURE ), cv.Optional(CONF_HUMIDITY): sensor.sensor_schema( UNIT_PERCENT, ICON_EMPTY, 1, DEVICE_CLASS_HUMIDITY ), cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema( UNIT_PERCENT, ICON_EMPTY, 0, DEVICE_CLASS_BATTERY ), } ) .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA) .extend(cv.COMPONENT_SCHEMA)
CONF_CLOSE_DURATION, CONF_CLOSE_ENDSTOP, CONF_ID, CONF_OPEN_ACTION, CONF_OPEN_DURATION, CONF_OPEN_ENDSTOP, CONF_STOP_ACTION, CONF_MAX_DURATION, ) endstop_ns = cg.esphome_ns.namespace("endstop") EndstopCover = endstop_ns.class_("EndstopCover", cover.Cover, cg.Component) CONFIG_SCHEMA = cover.COVER_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(EndstopCover), cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True), cv.Required(CONF_OPEN_ENDSTOP): cv.use_id(binary_sensor.BinarySensor), cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True), cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds, cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True), cv.Required(CONF_CLOSE_ENDSTOP): cv.use_id(binary_sensor.BinarySensor), cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds, cv.Optional(CONF_MAX_DURATION):
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import button from esphome.const import ( CONF_ID, DEVICE_CLASS_RESTART, ENTITY_CATEGORY_CONFIG, ) restart_ns = cg.esphome_ns.namespace("restart") RestartButton = restart_ns.class_("RestartButton", button.Button, cg.Component) CONFIG_SCHEMA = (button.button_schema( device_class=DEVICE_CLASS_RESTART, entity_category=ENTITY_CATEGORY_CONFIG).extend({ cv.GenerateID(): cv.declare_id(RestartButton) }).extend(cv.COMPONENT_SCHEMA)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await button.register_button(var, config)