import esphome.codegen as cg import esphome.config_validation as cv from esphome.const import CONF_ID from esphome.components import Filesystem AUTO_LOAD = ["Filesystem"] CONFLICTS_WITH = ["SD"] SD_MMC_FilesystemComponent = Filesystem.filesystem_ns.class_( "SD_MMC_Filesystem", cg.Component) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(CONF_ID): cv.declare_id(SD_MMC_FilesystemComponent), }).extend(cv.COMPONENT_SCHEMA)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config)
bmp085_ns = cg.esphome_ns.namespace("bmp085") BMP085Component = bmp085_ns.class_("BMP085Component", cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(BMP085Component), cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema( UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE, STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_PRESSURE): sensor.sensor_schema( UNIT_HECTOPASCAL, ICON_EMPTY, 1, DEVICE_CLASS_PRESSURE, STATE_CLASS_MEASUREMENT, ), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x77))) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config)
IS_PLATFORM_COMPONENT = True touchscreen_ns = cg.esphome_ns.namespace("touchscreen") Touchscreen = touchscreen_ns.class_("Touchscreen") TouchRotation = touchscreen_ns.enum("TouchRotation") TouchPoint = touchscreen_ns.struct("TouchPoint") TouchListener = touchscreen_ns.class_("TouchListener") CONF_DISPLAY = "display" CONF_TOUCHSCREEN_ID = "touchscreen_id" TOUCHSCREEN_SCHEMA = cv.Schema({ cv.GenerateID(CONF_DISPLAY): cv.use_id(display.DisplayBuffer), cv.Optional(CONF_ON_TOUCH): automation.validate_automation(single=True), }) async def register_touchscreen(var, config): disp = await cg.get_variable(config[CONF_DISPLAY]) cg.add(var.set_display(disp)) if CONF_ON_TOUCH in config: await automation.build_automation( var.get_touch_trigger(), [(TouchPoint, "touch")], config[CONF_ON_TOUCH], )
"U_QWORDU_R": 4, "S_QWORD": 4, "U_QWORD_R": 4, "FP32": 2, "FP32_R": 2, } MULTI_CONF = True _LOGGER = logging.getLogger(__name__) CONFIG_SCHEMA = cv.All( cv.Schema({ cv.GenerateID(): cv.declare_id(ModbusController), cv.Optional(CONF_COMMAND_THROTTLE, default="0ms"): cv.positive_time_period_milliseconds, }).extend(cv.polling_component_schema("60s")).extend( modbus.modbus_device_schema(0x01))) ModbusItemBaseSchema = cv.Schema( { cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController), cv.Optional(CONF_ADDRESS): cv.positive_int, cv.Optional(CONF_CUSTOM_COMMAND): cv.ensure_list(cv.hex_uint8_t), cv.Exclusive( CONF_OFFSET, "offset",
mpu6050_ns = cg.esphome_ns.namespace('mpu6050') MPU6050Component = mpu6050_ns.class_('MPU6050Component', cg.PollingComponent, i2c.I2CDevice) accel_schema = sensor.sensor_schema(UNIT_METER_PER_SECOND_SQUARED, ICON_BRIEFCASE_DOWNLOAD, 2) gyro_schema = sensor.sensor_schema(UNIT_DEGREE_PER_SECOND, ICON_SCREEN_ROTATION, 2) temperature_schema = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(MPU6050Component), cv.Optional(CONF_ACCEL_X): accel_schema, cv.Optional(CONF_ACCEL_Y): accel_schema, cv.Optional(CONF_ACCEL_Z): accel_schema, cv.Optional(CONF_GYRO_X): gyro_schema, cv.Optional(CONF_GYRO_Y): gyro_schema, cv.Optional(CONF_GYRO_Z): gyro_schema, cv.Optional(CONF_TEMPERATURE): temperature_schema, }).extend(cv.polling_component_schema('60s')).extend( i2c.i2c_device_schema(0x68)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config) for d in ['x', 'y', 'z']: accel_key = f'accel_{d}' if accel_key in config:
cv.Optional( CONF_MIN_SAVE_INTERVAL, default="0s" ): cv.positive_time_period_milliseconds, 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.Required(CONF_POWER_ID): cv.use_id(sensor.Sensor), }, extra=cv.ALLOW_EXTRA, ), inherit_property_from(CONF_ICON, CONF_POWER_ID), ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await sensor.register_sensor(var, config) sens = await cg.get_variable(config[CONF_POWER_ID]) cg.add(var.set_parent(sens))
CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(FingerprintGrowComponent), cv.Optional(CONF_SENSING_PIN): pins.gpio_input_pin_schema, cv.Optional(CONF_PASSWORD): cv.uint32_t, cv.Optional(CONF_NEW_PASSWORD): cv.uint32_t, cv.Optional(CONF_ON_FINGER_SCAN_MATCHED): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(FingerScanMatchedTrigger), }), cv.Optional(CONF_ON_FINGER_SCAN_UNMATCHED): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(FingerScanUnmatchedTrigger), }), cv.Optional(CONF_ON_ENROLLMENT_SCAN): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(EnrollmentScanTrigger), }), cv.Optional(CONF_ON_ENROLLMENT_DONE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(EnrollmentDoneTrigger), }), cv.Optional(CONF_ON_ENROLLMENT_FAILED): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(EnrollmentFailedTrigger), }), }).extend(cv.polling_component_schema("500ms")).extend( uart.UART_DEVICE_SCHEMA))
cv.Optional(CONF_SWING_HORIZONTAL_ACTION): automation.validate_automation(single=True), cv.Optional(CONF_SWING_OFF_ACTION): automation.validate_automation(single=True), cv.Optional(CONF_SWING_VERTICAL_ACTION): automation.validate_automation(single=True), cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature, cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature, cv.Optional(CONF_HYSTERESIS, default=0.5): cv.temperature, cv.Optional(CONF_AWAY_CONFIG): cv.Schema({ cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature, cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature, }), }).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_COOL_ACTION, CONF_DRY_ACTION, CONF_FAN_ONLY_ACTION, CONF_HEAT_ACTION), validate_thermostat, ) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield climate.register_climate(var, config) auto_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config
DEPENDENCIES = ["i2c"] bmp085_ns = cg.esphome_ns.namespace("bmp085") BMP085Component = bmp085_ns.class_("BMP085Component", cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(BMP085Component), 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_PRESSURE): sensor.sensor_schema( unit_of_measurement=UNIT_HECTOPASCAL, accuracy_decimals=1, device_class=DEVICE_CLASS_PRESSURE, state_class=STATE_CLASS_MEASUREMENT, ), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x77))) 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)
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 CODEOWNERS = ['@esphome/core'] 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) cg.add(var.set_sda_pin(config[CONF_SDA])) cg.add(var.set_scl_pin(config[CONF_SCL]))
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c, mcp23x17_base, mcp23xxx_base from esphome.const import CONF_ID AUTO_LOAD = ["mcp23x17_base"] CODEOWNERS = ["@jesserockz"] DEPENDENCIES = ["i2c"] MULTI_CONF = True mcp23017_ns = cg.esphome_ns.namespace("mcp23017") MCP23017 = mcp23017_ns.class_("MCP23017", mcp23x17_base.MCP23X17Base, i2c.I2CDevice) CONFIG_SCHEMA = (cv.Schema({ cv.Required(CONF_ID): cv.declare_id(MCP23017), }).extend(mcp23xxx_base.MCP23XXX_CONFIG_SCHEMA).extend( i2c.i2c_device_schema(0x20))) async def to_code(config): var = await mcp23xxx_base.register_mcp23xxx(config) await i2c.register_i2c_device(var, config)
raise cv.Invalid("WPA password must be at most 64 characters long") return value def validate_channel(value): value = cv.positive_int(value) if value < 1: raise cv.Invalid("Minimum WiFi channel is 1") if value > 14: raise cv.Invalid("Maximum WiFi channel is 14") return value AP_MANUAL_IP_SCHEMA = cv.Schema({ cv.Required(CONF_STATIC_IP): cv.ipv4, cv.Required(CONF_GATEWAY): cv.ipv4, cv.Required(CONF_SUBNET): cv.ipv4, }) STA_MANUAL_IP_SCHEMA = AP_MANUAL_IP_SCHEMA.extend({ cv.Optional(CONF_DNS1, default="0.0.0.0"): cv.ipv4, cv.Optional(CONF_DNS2, default="0.0.0.0"): cv.ipv4, }) WIFI_NETWORK_BASE = cv.Schema({ cv.GenerateID(): cv.declare_id(WiFiAP), cv.Optional(CONF_SSID): cv.ssid,
DEPENDENCIES = ["i2c"] aht10_ns = cg.esphome_ns.namespace("aht10") AHT10Component = aht10_ns.class_("AHT10Component", cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = ( cv.Schema( { cv.GenerateID(): cv.declare_id(AHT10Component), 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, ), cv.Optional(CONF_HUMIDITY): sensor.sensor_schema( unit_of_measurement=UNIT_PERCENT, accuracy_decimals=2, device_class=DEVICE_CLASS_HUMIDITY, state_class=STATE_CLASS_MEASUREMENT, ), } ) .extend(cv.polling_component_schema("60s")) .extend(i2c.i2c_device_schema(0x38)) ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config)
} validate_climate_swing_mode = cv.enum(CLIMATE_SWING_MODES, upper=True) # Actions ControlAction = climate_ns.class_("ControlAction", automation.Action) StateTrigger = climate_ns.class_("StateTrigger", automation.Trigger.template()) CLIMATE_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend( { cv.GenerateID(): cv.declare_id(Climate), cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTClimateComponent), cv.Optional(CONF_VISUAL, default={}): cv.Schema( { cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature, cv.Optional(CONF_MAX_TEMPERATURE): cv.temperature, cv.Optional(CONF_TEMPERATURE_STEP): cv.temperature, } ), cv.Optional(CONF_ACTION_STATE_TOPIC): cv.All( cv.requires_component("mqtt"), cv.publish_topic ), cv.Optional(CONF_AWAY_COMMAND_TOPIC): cv.All( cv.requires_component("mqtt"), cv.publish_topic ), cv.Optional(CONF_AWAY_STATE_TOPIC): cv.All( cv.requires_component("mqtt"), cv.publish_topic ), cv.Optional(CONF_CURRENT_TEMPERATURE_STATE_TOPIC): cv.All( cv.requires_component("mqtt"), cv.publish_topic ),
CONFIG_SCHEMA = cv.All( cv.Schema({ cv.GenerateID(): cv.declare_id(XPT2046Component), cv.Optional(CONF_IRQ_PIN): pins.gpio_input_pin_schema, cv.Optional(CONF_CALIBRATION_X_MIN, default=0): cv.int_range(min=0, max=4095), cv.Optional(CONF_CALIBRATION_X_MAX, default=4095): cv.int_range(min=0, max=4095), cv.Optional(CONF_CALIBRATION_Y_MIN, default=0): cv.int_range(min=0, max=4095), cv.Optional(CONF_CALIBRATION_Y_MAX, default=4095): cv.int_range(min=0, max=4095), cv.Optional(CONF_DIMENSION_X, default=100): cv.positive_not_null_int, cv.Optional(CONF_DIMENSION_Y, default=100): cv.positive_not_null_int, cv.Optional(CONF_THRESHOLD, default=400): cv.int_range(min=0, max=4095), cv.Optional(CONF_REPORT_INTERVAL, default="never"): report_interval, cv.Optional(CONF_SWAP_X_Y, default=False): cv.boolean, cv.Optional(CONF_ON_STATE): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(XPT2046OnStateTrigger), }), }).extend(cv.polling_component_schema("50ms")).extend( spi.spi_device_schema()), validate_xpt2046,
CONFIG_SCHEMA = sensor.sensor_schema( UNIT_PULSES_PER_MINUTE, ICON_PULSE, 2).extend({ cv.GenerateID(): cv.declare_id(PulseCounterSensor), cv.Required(CONF_PIN): validate_pulse_counter_pin, cv.Optional(CONF_COUNT_MODE, default={ CONF_RISING_EDGE: 'INCREMENT', CONF_FALLING_EDGE: 'DISABLE', }): cv.All( cv.Schema({ cv.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA, cv.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA, }), validate_count_mode), cv.Optional(CONF_INTERNAL_FILTER, default='13us'): validate_internal_filter, cv.Optional(CONF_TOTAL): sensor.sensor_schema(UNIT_PULSES, ICON_PULSE, 0), }).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) pin = yield cg.gpio_pin_expression(config[CONF_PIN]) cg.add(var.set_pin(pin))
CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(PZEMAC), cv.Optional(CONF_VOLTAGE): sensor.sensor_schema( unit_of_measurement=UNIT_VOLT, accuracy_decimals=1, device_class=DEVICE_CLASS_VOLTAGE, state_class=STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_CURRENT): sensor.sensor_schema( unit_of_measurement=UNIT_AMPERE, accuracy_decimals=3, device_class=DEVICE_CLASS_CURRENT, state_class=STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_POWER): sensor.sensor_schema( unit_of_measurement=UNIT_WATT, accuracy_decimals=2, device_class=DEVICE_CLASS_POWER, state_class=STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_ENERGY): sensor.sensor_schema( unit_of_measurement=UNIT_WATT_HOURS, accuracy_decimals=0, device_class=DEVICE_CLASS_ENERGY, state_class=STATE_CLASS_TOTAL_INCREASING, ), cv.Optional(CONF_FREQUENCY): sensor.sensor_schema( unit_of_measurement=UNIT_HERTZ, icon=ICON_CURRENT_AC, accuracy_decimals=1, state_class=STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema( accuracy_decimals=2, device_class=DEVICE_CLASS_POWER_FACTOR, state_class=STATE_CLASS_MEASUREMENT, ), }).extend(cv.polling_component_schema("60s")).extend( modbus.modbus_device_schema(0x01)))
import esphome.codegen as cg import esphome.config_validation as cv from esphome import core, pins, automation from esphome.automation import maybe_simple_id from esphome.const import CONF_ID, CONF_ADDRESS, CONF_UPDATE_INTERVAL from esphome.components import modbus AUTO_LOAD = ['modbus', 'sensor'] genvex_ns = cg.esphome_ns.namespace('genvex') Genvex = genvex_ns.class_('Genvex', cg.PollingComponent, modbus.ModbusDevice) CONF_GENVEX_ID = 'genvex_id' CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(Genvex), cv.Required(CONF_ADDRESS): cv.int_range(min=1, max=100), }).extend(cv.polling_component_schema('60s')).extend(modbus.modbus_device_schema(0x01)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield modbus.register_modbus_device(var, config) if CONF_ADDRESS in config: cg.add(var.set_address(config[CONF_ADDRESS])) if CONF_UPDATE_INTERVAL in config: cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
import esphome.codegen as cg import esphome.config_validation as cv from esphome import automation from esphome.automation import maybe_simple_id from esphome.components import power_supply from esphome.const import CONF_ID, CONF_INVERTED, CONF_LEVEL, CONF_MAX_POWER, \ CONF_MIN_POWER, CONF_POWER_SUPPLY from esphome.core import CORE, coroutine CODEOWNERS = ['@esphome/core'] IS_PLATFORM_COMPONENT = True 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, }) output_ns = cg.esphome_ns.namespace('output') BinaryOutput = output_ns.class_('BinaryOutput') BinaryOutputPtr = BinaryOutput.operator('ptr') FloatOutput = output_ns.class_('FloatOutput', BinaryOutput) FloatOutputPtr = FloatOutput.operator('ptr')
from esphome.components import i2c, sensor from esphome.const import CONF_ID,\ CONF_BATTERY_LEVEL, CONF_BRIGHTNESS, UNIT_PERCENT, ICON_BATTERY DEPENDENCIES = ['i2c'] axp192_ns = cg.esphome_ns.namespace('axp192') AXP192Component = axp192_ns.class_('AXP192Component', cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(AXP192Component), cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(UNIT_PERCENT, ICON_BATTERY, 1).extend({}), cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage, }).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) if CONF_BATTERY_LEVEL in config: conf = config[CONF_BATTERY_LEVEL] sens = yield sensor.new_sensor(conf) cg.add(var.set_batterylevel_sensor(sens))
'int[]': cg.std_vector.template(cg.int32), 'float[]': cg.std_vector.template(float), 'string[]': cg.std_vector.template(cg.std_string), } CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(APIServer), cv.Optional(CONF_PORT, default=6053): cv.port, cv.Optional(CONF_PASSWORD, default=''): cv.string_strict, cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'): cv.positive_time_period_milliseconds, cv.Optional(CONF_SERVICES): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger), cv.Required(CONF_SERVICE): cv.valid_name, cv.Optional(CONF_VARIABLES, default={}): cv.Schema({ cv.validate_id_name: cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True), }), }), }).extend(cv.COMPONENT_SCHEMA) @coroutine_with_priority(40.0) def to_code(config): var = cg.new_Pvariable(config[CONF_ID])
field_strength_schema = sensor.sensor_schema(UNIT_MICROTESLA, ICON_MAGNET, 1, DEVICE_CLASS_EMPTY) heading_schema = sensor.sensor_schema(UNIT_DEGREES, ICON_SCREEN_ROTATION, 1, DEVICE_CLASS_EMPTY) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(HMC5883LComponent), cv.Optional(CONF_ADDRESS): cv.i2c_address, cv.Optional(CONF_OVERSAMPLING, default="1x"): validate_enum(HMC5883LOversamplings, units="x"), cv.Optional(CONF_RANGE, default="130µT"): validate_enum(HMC5883L_RANGES, units=["uT", "µT"]), cv.Optional(CONF_FIELD_STRENGTH_X): field_strength_schema, cv.Optional(CONF_FIELD_STRENGTH_Y): field_strength_schema, cv.Optional(CONF_FIELD_STRENGTH_Z): field_strength_schema, cv.Optional(CONF_HEADING): heading_schema, }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x1E))) def auto_data_rate(config): interval_sec = config[CONF_UPDATE_INTERVAL].seconds interval_hz = 1.0 / interval_sec for datarate in sorted(HMC5883LDatarates.keys()):
"16X": BMP280IIRFilter.BMP280_IIR_FILTER_16X, } BMP280Component = bmp280_ns.class_("BMP280Component", cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(BMP280Component), cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE).extend({ cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(OVERSAMPLING_OPTIONS, upper=True), }), cv.Optional(CONF_PRESSURE): sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_EMPTY, 1, DEVICE_CLASS_PRESSURE).extend({ cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(OVERSAMPLING_OPTIONS, upper=True), }), cv.Optional(CONF_IIR_FILTER, default="OFF"): cv.enum(IIR_FILTER_OPTIONS, upper=True), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x77))) 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)
CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(BME680Component), cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({ cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True), }), cv.Optional(CONF_PRESSURE): sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({ cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True), }), cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1).extend({ cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True), }), cv.Optional(CONF_GAS_RESISTANCE): sensor.sensor_schema(UNIT_OHM, ICON_GAS_CYLINDER, 1), cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True), cv.Optional(CONF_HEATER): cv.Any( None, cv.All( cv.Schema({ cv.Optional(CONF_TEMPERATURE, default=320): cv.int_range(min=200, max=400), cv.Optional(CONF_DURATION, default='150ms'): cv.All(cv.positive_time_period_milliseconds, cv.Range(max=core.TimePeriod(milliseconds=4032))) }), cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION))), }).extend(cv.polling_component_schema('60s')).extend( i2c.i2c_device_schema(0x76))
CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(CONF_DSMR_ID): cv.use_id(Dsmr), cv.Optional("energy_delivered_lux"): sensor.sensor_schema( UNIT_KILOWATT_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_ENERGY, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("energy_delivered_tariff1"): sensor.sensor_schema( UNIT_KILOWATT_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_ENERGY, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("energy_delivered_tariff2"): sensor.sensor_schema( UNIT_KILOWATT_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_ENERGY, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("energy_returned_lux"): sensor.sensor_schema( UNIT_KILOWATT_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_ENERGY, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("energy_returned_tariff1"): sensor.sensor_schema( UNIT_KILOWATT_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_ENERGY, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("energy_returned_tariff2"): sensor.sensor_schema( UNIT_KILOWATT_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_ENERGY, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("total_imported_energy"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE, ), cv.Optional("total_exported_energy"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE_HOURS, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE, ), cv.Optional("power_delivered"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("power_returned"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("reactive_power_delivered"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT, ), cv.Optional("reactive_power_returned"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT, ), cv.Optional("electricity_threshold"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_switch_position"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_failures"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_long_failures"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_sags_l1"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_sags_l2"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_sags_l3"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_swells_l1"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_swells_l2"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("electricity_swells_l3"): sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE), cv.Optional("current_l1"): sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 1, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT), cv.Optional("current_l2"): sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 1, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT), cv.Optional("current_l3"): sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 1, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT), cv.Optional("power_delivered_l1"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("power_delivered_l2"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("power_delivered_l3"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("power_returned_l1"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("power_returned_l2"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("power_returned_l3"): sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT), cv.Optional("reactive_power_delivered_l1"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional("reactive_power_delivered_l2"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional("reactive_power_delivered_l3"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional("reactive_power_returned_l1"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional("reactive_power_returned_l2"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional("reactive_power_returned_l3"): sensor.sensor_schema( UNIT_KILOVOLT_AMPS_REACTIVE, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional("voltage_l1"): sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE, STATE_CLASS_NONE), cv.Optional("voltage_l2"): sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE, STATE_CLASS_NONE), cv.Optional("voltage_l3"): sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE, STATE_CLASS_NONE), cv.Optional("gas_delivered"): sensor.sensor_schema( UNIT_CUBIC_METER, ICON_EMPTY, 3, DEVICE_CLASS_GAS, STATE_CLASS_TOTAL_INCREASING, ), cv.Optional("gas_delivered_be"): sensor.sensor_schema( UNIT_CUBIC_METER, ICON_EMPTY, 3, DEVICE_CLASS_GAS, STATE_CLASS_TOTAL_INCREASING, ), }).extend(cv.COMPONENT_SCHEMA)
}).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 text_sensor.register_text_sensor(var, config) if CONF_LAMBDA in config: template_ = await cg.process_lambda(config[CONF_LAMBDA], [], return_type=cg.optional.template( cg.std_string)) cg.add(var.set_template(template_)) @automation.register_action( "text_sensor.template.publish", TextSensorPublishAction, cv.Schema({ cv.Required(CONF_ID): cv.use_id(text_sensor.TextSensor), cv.Required(CONF_STATE): cv.templatable(cv.string_strict), }), ) async def text_sensor_template_publish_to_code(config, action_id, template_arg, args): paren = await cg.get_variable(config[CONF_ID]) var = cg.new_Pvariable(action_id, template_arg, paren) template_ = await cg.templatable(config[CONF_STATE], args, cg.std_string) cg.add(var.set_state(template_)) return var
path=[CONF_BOARD], ) value = value.copy() value[CONF_VARIANT] = BOARD_TO_VARIANT[board] 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, ) CONF_SDKCONFIG_OPTIONS = "sdkconfig_options" ESP_IDF_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, cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): { cv.string_strict: cv.string_strict
DEPENDENCIES = ["esp32_ble_tracker"] AUTO_LOAD = ["xiaomi_ble"] xiaomi_lywsd02_ns = cg.esphome_ns.namespace("xiaomi_lywsd02") XiaomiLYWSD02 = xiaomi_lywsd02_ns.class_("XiaomiLYWSD02", esp32_ble_tracker.ESPBTDeviceListener, cg.Component) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(XiaomiLYWSD02), 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)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await esp32_ble_tracker.register_ble_device(var, config) cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
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, cv.Optional(CONF_ON_STATE_CHANGE): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAStateChangeTrigger), } ), cv.Optional(CONF_ON_BEGIN): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAStartTrigger), } ), cv.Optional(CONF_ON_ERROR): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAErrorTrigger), } ), cv.Optional(CONF_ON_PROGRESS): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAProgressTrigger), } ), cv.Optional(CONF_ON_END): automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAEndTrigger), } ), } ).extend(cv.COMPONENT_SCHEMA)
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import binary_sensor from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA from .. import custom_ns CustomBinarySensorConstructor = custom_ns.class_( "CustomBinarySensorConstructor") CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(CustomBinarySensorConstructor), cv.Required(CONF_LAMBDA): cv.returning_lambda, cv.Required(CONF_BINARY_SENSORS): cv.ensure_list(binary_sensor.binary_sensor_schema()), }) async def to_code(config): template_ = await cg.process_lambda( config[CONF_LAMBDA], [], return_type=cg.std_vector.template(binary_sensor.BinarySensorPtr), ) rhs = CustomBinarySensorConstructor(template_) custom = cg.variable(config[CONF_ID], rhs) for i, conf in enumerate(config[CONF_BINARY_SENSORS]): rhs = custom.Pget_binary_sensor(i) await binary_sensor.register_binary_sensor(rhs, conf)