CONFIG_SCHEMA = (sensor.sensor_schema( UNIT_EMPTY, ICON_RADIATOR, 0, DEVICE_CLASS_EMPTY).extend({ cv.GenerateID(): cv.declare_id(SGP40Component), cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean, cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t, cv.Optional(CONF_COMPENSATION): cv.Schema( { cv.Required(CONF_HUMIDITY_SOURCE): cv.use_id(sensor.Sensor), cv.Required(CONF_TEMPERATURE_SOURCE): cv.use_id(sensor.Sensor), }, ), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x59))) 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) await sensor.register_sensor(var, config) if CONF_COMPENSATION in config: compensation_config = config[CONF_COMPENSATION] sens = await cg.get_variable(compensation_config[CONF_HUMIDITY_SOURCE]) cg.add(var.set_humidity_sensor(sens)) sens = await cg.get_variable( compensation_config[CONF_TEMPERATURE_SOURCE]) cg.add(var.set_temperature_sensor(sens))
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_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 1, DEVICE_CLASS_HUMIDITY).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) if CONF_TEMPERATURE in config: conf = config[CONF_TEMPERATURE] sens = await sensor.new_sensor(conf) cg.add(var.set_temperature_sensor(sens)) cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING])) if CONF_PRESSURE in config: conf = config[CONF_PRESSURE]
cv.Required(CONF_TVOC): sensor.sensor_schema( UNIT_PARTS_PER_BILLION, ICON_RADIATOR, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_BASELINE): cv.hex_uint16_t, cv.Optional(CONF_TEMPERATURE): cv.use_id(sensor.Sensor), cv.Optional(CONF_HUMIDITY): cv.use_id(sensor.Sensor), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x5A))) 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) sens = await sensor.new_sensor(config[CONF_ECO2]) cg.add(var.set_co2(sens)) sens = await sensor.new_sensor(config[CONF_TVOC]) cg.add(var.set_tvoc(sens)) if CONF_BASELINE in config: cg.add(var.set_baseline(config[CONF_BASELINE]))
PCF8574GPIOMode = pcf8574_ns.enum('PCF8574GPIOMode') PCF8674_GPIO_MODES = { 'INPUT': PCF8574GPIOMode.PCF8574_INPUT, 'OUTPUT': PCF8574GPIOMode.PCF8574_OUTPUT, } PCF8574Component = pcf8574_ns.class_('PCF8574Component', cg.Component, i2c.I2CDevice) PCF8574GPIOPin = pcf8574_ns.class_('PCF8574GPIOPin', cg.GPIOPin) CONF_PCF8574 = 'pcf8574' CONF_PCF8575 = 'pcf8575' CONFIG_SCHEMA = cv.Schema({ cv.Required(CONF_ID): cv.declare_id(PCF8574Component), cv.Optional(CONF_PCF8575, default=False): cv.boolean, }).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x21)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config) cg.add(var.set_pcf8575(config[CONF_PCF8575])) def validate_pcf8574_gpio_mode(value): value = cv.string(value) if value.upper() == 'INPUT_PULLUP': raise cv.Invalid( "INPUT_PULLUP mode has been removed in 1.14 and been combined into " "INPUT mode (they were the same thing). Please use INPUT instead.")
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c, sensor from esphome.const import CONF_ID CODEOWNERS = ["@ssieb"] DEPENDENCIES = ["i2c"] ezo_ns = cg.esphome_ns.namespace("ezo") EZOSensor = ezo_ns.class_("EZOSensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(EZOSensor), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(None))) 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)
automation.validate_automation(single=True), cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation(single=True), cv.Optional(CONF_ON_LONG_CLICK): automation.validate_automation(single=True), }), cv.Optional(CONF_B): cv.Schema({ cv.Optional(CONF_ON_CLICK): automation.validate_automation(single=True), cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation(single=True), cv.Optional(CONF_ON_LONG_CLICK): automation.validate_automation(single=True), }), }).extend(i2c.i2c_device_schema(0x31)) 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) if CONF_A in config: conf = config[CONF_A] if CONF_ON_CLICK in conf: await automation.build_automation(var.get_a_click_trigger(), [], conf[CONF_ON_CLICK]) if CONF_ON_DOUBLE_CLICK in conf: await automation.build_automation(var.get_a_double_click_trigger(), [], conf[CONF_ON_DOUBLE_CLICK])
from esphome.components import i2c, sensor from esphome.const import ( CONF_ID, DEVICE_CLASS_TEMPERATURE, ICON_EMPTY, STATE_CLASS_MEASUREMENT, UNIT_CELSIUS, ) CODEOWNERS = ["@k7hpn"] DEPENDENCIES = ["i2c"] mcp9808_ns = cg.esphome_ns.namespace("mcp9808") MCP9808Sensor = mcp9808_ns.class_("MCP9808Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (sensor.sensor_schema( UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE, STATE_CLASS_MEASUREMENT).extend({ cv.GenerateID(): cv.declare_id(MCP9808Sensor), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x18))) 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) await sensor.register_sensor(var, config)
cv.Optional(CONF_ALTITUDE_COMPENSATION): cv.All( cv.float_with_unit("altitude", "(m|m a.s.l.|MAMSL|MASL)"), cv.int_range(min=0, max=0xFFFF, max_included=False), ), cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION, default=0): cv.pressure, cv.Optional(CONF_TEMPERATURE_OFFSET): cv.temperature, cv.Optional(CONF_UPDATE_INTERVAL, default="60s"): cv.All( cv.positive_time_period_seconds, cv.Range( min=core.TimePeriod(seconds=1), max=core.TimePeriod(seconds=1800) ), ), } ) .extend(cv.COMPONENT_SCHEMA) .extend(i2c.i2c_device_schema(0x61)) ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await i2c.register_i2c_device(var, config) cg.add(var.set_automatic_self_calibration(config[CONF_AUTOMATIC_SELF_CALIBRATION])) if CONF_ALTITUDE_COMPENSATION in config: cg.add(var.set_altitude_compensation(config[CONF_ALTITUDE_COMPENSATION])) if CONF_AMBIENT_PRESSURE_COMPENSATION in config: cg.add( var.set_ambient_pressure_compensation(
CODEOWNERS = ["@k7hpn"] DEPENDENCIES = ["i2c"] mcp9808_ns = cg.esphome_ns.namespace("mcp9808") MCP9808Sensor = mcp9808_ns.class_( "MCP9808Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice ) CONFIG_SCHEMA = ( sensor.sensor_schema( unit_of_measurement=UNIT_CELSIUS, accuracy_decimals=1, device_class=DEVICE_CLASS_TEMPERATURE, state_class=STATE_CLASS_MEASUREMENT, ) .extend( { cv.GenerateID(): cv.declare_id(MCP9808Sensor), } ) .extend(cv.polling_component_schema("60s")) .extend(i2c.i2c_device_schema(0x18)) ) 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) await sensor.register_sensor(var, config)
DEPENDENCIES = ['i2c'] htu21d_ns = cg.esphome_ns.namespace('htu21d') HTU21DComponent = htu21d_ns.class_('HTU21DComponent', cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(HTU21DComponent), cv.Required(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1), cv.Required(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1), }).extend(cv.polling_component_schema('60s')).extend( i2c.i2c_device_schema(0x40)) 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_TEMPERATURE in config: sens = yield sensor.new_sensor(config[CONF_TEMPERATURE]) cg.add(var.set_temperature(sens)) if CONF_HUMIDITY in config: sens = yield sensor.new_sensor(config[CONF_HUMIDITY]) cg.add(var.set_humidity(sens))
DEPENDENCIES = ["i2c"] CODEOWNERS = ["@Azimath"] tmp117_ns = cg.esphome_ns.namespace("tmp117") TMP117Component = tmp117_ns.class_("TMP117Component", cg.PollingComponent, i2c.I2CDevice, sensor.Sensor) CONFIG_SCHEMA = cv.All( sensor.sensor_schema( TMP117Component, unit_of_measurement=UNIT_CELSIUS, accuracy_decimals=1, device_class=DEVICE_CLASS_TEMPERATURE, state_class=STATE_CLASS_MEASUREMENT, ).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x48))) def determine_config_register(polling_period): if polling_period >= 16.0: # 64 averaged conversions, max conversion time # 0000 00 111 11 00000 # 0000 0011 1110 0000 return 0x03E0 if polling_period >= 8.0: # 64 averaged conversions, high conversion time # 0000 00 110 11 00000 # 0000 0011 0110 0000 return 0x0360 if polling_period >= 4.0: # 64 averaged conversions, mid conversion time
cg.PollingComponent, i2c.I2CDevice) MAX44009Mode = max44009_ns.enum("MAX44009Mode") MODE_OPTIONS = { "auto": MAX44009Mode.MAX44009_MODE_AUTO, "low_power": MAX44009Mode.MAX44009_MODE_LOW_POWER, "continuous": MAX44009Mode.MAX44009_MODE_CONTINUOUS, } CONFIG_SCHEMA = (sensor.sensor_schema( unit_of_measurement=UNIT_LUX, accuracy_decimals=3, device_class=DEVICE_CLASS_ILLUMINANCE, state_class=STATE_CLASS_MEASUREMENT, ).extend({ cv.GenerateID(): cv.declare_id(MAX44009Sensor), cv.Optional(CONF_MODE, default="low_power"): cv.enum(MODE_OPTIONS, lower=True), }).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 i2c.register_i2c_device(var, config) await sensor.register_sensor(var, config) cg.add(var.set_mode(config[CONF_MODE]))
import esphome.config_validation as cv from esphome.components import i2c, sensor from esphome.const import CONF_ID CODEOWNERS = ["@ssieb"] DEPENDENCIES = ["i2c"] ezo_ns = cg.esphome_ns.namespace("ezo") EZOSensor = ezo_ns.class_( "EZOSensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice ) CONFIG_SCHEMA = ( sensor.SENSOR_SCHEMA.extend( { cv.GenerateID(): cv.declare_id(EZOSensor), } ) .extend(cv.polling_component_schema("60s")) .extend(i2c.i2c_device_schema(None)) ) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield sensor.register_sensor(var, config) yield i2c.register_i2c_device(var, config)
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c, sensor from esphome.const import CONF_ID DEPENDENCIES = ['i2c'] CONF_I2C_ADDR = 0x01 empty_i2c_component_ns = cg.esphome_ns.namespace('empty_i2c_component') EmptyI2CComponent = empty_i2c_component_ns.class_('EmptyI2CComponent', cg.Component, i2c.I2CDevice) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(EmptyI2CComponent) }).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(CONF_I2C_ADDR)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config)
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_CELSIUS, ICON_EMPTY, 2, DEVICE_CLASS_TEMPERATURE), cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 2, DEVICE_CLASS_HUMIDITY), }).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) await i2c.register_i2c_device(var, config) if CONF_TEMPERATURE in config: sens = await sensor.new_sensor(config[CONF_TEMPERATURE]) cg.add(var.set_temperature_sensor(sens)) if CONF_HUMIDITY in config: sens = await sensor.new_sensor(config[CONF_HUMIDITY]) cg.add(var.set_humidity_sensor(sens))
DEPENDENCIES = ["i2c"] dht12_ns = cg.esphome_ns.namespace("dht12") DHT12Component = dht12_ns.class_("DHT12Component", cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(DHT12Component), 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), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x5C))) 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) if CONF_TEMPERATURE in config: sens = await sensor.new_sensor(config[CONF_TEMPERATURE]) cg.add(var.set_temperature_sensor(sens)) if CONF_HUMIDITY in config: sens = await sensor.new_sensor(config[CONF_HUMIDITY]) cg.add(var.set_humidity_sensor(sens))
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c, pn532 from esphome.const import CONF_ID AUTO_LOAD = ["pn532"] CODEOWNERS = ["@OttoWinter", "@jesserockz"] DEPENDENCIES = ["i2c"] pn532_i2c_ns = cg.esphome_ns.namespace("pn532_i2c") PN532I2C = pn532_i2c_ns.class_("PN532I2C", pn532.PN532, i2c.I2CDevice) CONFIG_SCHEMA = cv.All( pn532.PN532_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(PN532I2C), }).extend(i2c.i2c_device_schema(0x24))) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield pn532.setup_pn532(var, config) yield i2c.register_i2c_device(var, config)
cv.Optional(CONF_ADDRESS): cv.i2c_address, cv.Optional(CONF_RANGE, default="200µT"): validate_enum(QMC5883L_RANGES, units=["uT", "µT"]), cv.Optional(CONF_OVERSAMPLING, default="512x"): validate_enum(QMC5883LOversamplings, units="x"), 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(0x0D))) def auto_data_rate(config): interval_sec = config[CONF_UPDATE_INTERVAL].seconds interval_hz = 1.0 / interval_sec for datarate in sorted(QMC5883LDatarates.keys()): if float(datarate) >= interval_hz: return QMC5883LDatarates[datarate] return QMC5883LDatarates[200] 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)
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()): if float(datarate) >= interval_hz: return HMC5883LDatarates[datarate] return HMC5883LDatarates[75] 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)
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))) 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) if CONF_TEMPERATURE in config: conf = config[CONF_TEMPERATURE] sens = await sensor.new_sensor(conf) cg.add(var.set_temperature_sensor(sens)) cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING])) if CONF_PRESSURE in config: conf = config[CONF_PRESSURE]
UNIT_PERCENT, ICON_WATER_PERCENT, 2, DEVICE_CLASS_HUMIDITY, STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_PRECISION, default="High"): cv.enum(PRECISION_OPTIONS), cv.Optional(CONF_HEATER_POWER, default="High"): cv.enum(HEATER_POWER_OPTIONS), cv.Optional(CONF_HEATER_TIME, default="Long"): cv.enum(HEATER_TIME_OPTIONS), cv.Optional(CONF_HEATER_MAX_DUTY, default=0.0): cv.float_range(min=0.0, max=0.05), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x44))) TYPES = { CONF_TEMPERATURE: "set_temp_sensor", CONF_HUMIDITY: "set_humidity_sensor", } async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await i2c.register_i2c_device(var, config) cg.add(var.set_precision_value(config[CONF_PRECISION])) cg.add(var.set_heater_power_value(config[CONF_HEATER_POWER])) cg.add(var.set_heater_time_value(config[CONF_HEATER_TIME]))
cv.Optional(CONF_PMC_10_0): sensor.sensor_schema( unit_of_measurement=UNIT_COUNTS_PER_CUBIC_METER, icon=ICON_COUNTER, accuracy_decimals=2, state_class=STATE_CLASS_MEASUREMENT, ), cv.Optional(CONF_PM_SIZE): sensor.sensor_schema( unit_of_measurement=UNIT_MICROMETER, icon=ICON_RULER, accuracy_decimals=0, state_class=STATE_CLASS_MEASUREMENT, ), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x69))) 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) if CONF_PM_1_0 in config: sens = await sensor.new_sensor(config[CONF_PM_1_0]) cg.add(var.set_pm_1_0_sensor(sens)) if CONF_PM_2_5 in config: sens = await sensor.new_sensor(config[CONF_PM_2_5]) cg.add(var.set_pm_2_5_sensor(sens))
CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(SCD30Component), cv.Required(CONF_CO2): sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_PERIODIC_TABLE_CO2, 0), cv.Required(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1), cv.Required(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1), cv.Optional(CONF_AUTOMATIC_SELF_CALIBRATION, default=True): cv.boolean, cv.Optional(CONF_ALTITUDE_COMPENSATION): cv.All(remove_altitude_suffix, cv.int_range(min=0, max=0xFFFF, max_included=False)), }).extend(cv.polling_component_schema('60s')).extend( i2c.i2c_device_schema(0x61)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config) cg.add( var.set_automatic_self_calibration( config[CONF_AUTOMATIC_SELF_CALIBRATION])) if CONF_ALTITUDE_COMPENSATION in config: cg.add( var.set_altitude_compensation(config[CONF_ALTITUDE_COMPENSATION])) if CONF_CO2 in config:
DEVICE_CLASS_EMPTY).extend({ cv.GenerateID(): cv.declare_id(VL53L0XSensor), cv.Optional(CONF_SIGNAL_RATE_LIMIT, default=0.25): cv.float_range(min=0.0, max=512.0, min_included=False, max_included=False), cv.Optional(CONF_LONG_RANGE, default=False): cv.boolean, cv.Optional(CONF_TIMEOUT, default="10ms"): check_timeout, cv.Optional(CONF_ENABLE_PIN): pins.gpio_output_pin_schema, }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x29)), check_keys, ) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) cg.add(var.set_signal_rate_limit(config[CONF_SIGNAL_RATE_LIMIT])) cg.add(var.set_long_range(config[CONF_LONG_RANGE])) cg.add(var.set_timeout_us(config[CONF_TIMEOUT])) if CONF_ENABLE_PIN in config: enable = yield cg.gpio_pin_expression(config[CONF_ENABLE_PIN]) cg.add(var.set_enable_pin(enable))
DEPENDENCIES = ['i2c'] ht16k33_alpha_ns = cg.esphome_ns.namespace('ht16k33_alpha') HT16K33AlphaDisplay = ht16k33_alpha_ns.class_('HT16K33AlphaDisplay', cg.PollingComponent, i2c.I2CDevice) CONF_SCROLL = "scroll" CONF_SCROLL_SPEED = "scroll_speed" CONF_SCROLL_DWELL = "scroll_dwell" CONF_SCROLL_DELAY = "scroll_delay" CONF_SECONDARY_DISPLAYS = "secondary_displays" CONFIG_SECONDARY = cv.Schema({ cv.GenerateID(): cv.declare_id(i2c.I2CDevice) }).extend(i2c.i2c_device_schema(None)) CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(HT16K33AlphaDisplay), cv.Optional(CONF_SCROLL, default=False): cv.boolean, cv.Optional(CONF_SCROLL_SPEED, default='250ms'): cv.positive_time_period_milliseconds, cv.Optional(CONF_SCROLL_DWELL, default='2s'): cv.positive_time_period_milliseconds, cv.Optional(CONF_SCROLL_DELAY, default='3'): cv.float_range(min=1), cv.Optional(CONF_SECONDARY_DISPLAYS): cv.ensure_list(CONFIG_SECONDARY), }).extend(cv.polling_component_schema('1s')).extend(
def validate_integration_time(value): value = cv.positive_time_period_milliseconds(value).total_milliseconds return cv.enum(INTEGRATION_TIMES, int=True)(value) TSL2561Sensor = tsl2561_ns.class_('TSL2561Sensor', sensor.Sensor, cg.PollingComponent, i2c.I2CDevice) CONFIG_SCHEMA = sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1).extend({ cv.GenerateID(): cv.declare_id(TSL2561Sensor), cv.Optional(CONF_INTEGRATION_TIME, default='402ms'): validate_integration_time, cv.Optional(CONF_GAIN, default='1X'): cv.enum(GAINS, upper=True), cv.Optional(CONF_IS_CS_PACKAGE, default=False): cv.boolean, }).extend(cv.polling_component_schema('60s')).extend( i2c.i2c_device_schema(0x39)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config) yield sensor.register_sensor(var, config) cg.add(var.set_integration_time(config[CONF_INTEGRATION_TIME])) cg.add(var.set_gain(config[CONF_GAIN])) cg.add(var.set_is_cs_package(config[CONF_IS_CS_PACKAGE]))
cv.Optional(CONF_GREEN_CHANNEL): color_channel_schema, cv.Optional(CONF_BLUE_CHANNEL): color_channel_schema, cv.Optional(CONF_CLEAR_CHANNEL): color_channel_schema, cv.Optional(CONF_ILLUMINANCE): illuminance_schema, cv.Optional(CONF_COLOR_TEMPERATURE): color_temperature_schema, cv.Optional(CONF_INTEGRATION_TIME, default="auto"): cv.enum( TCS34725_INTEGRATION_TIMES, lower=True ), cv.Optional(CONF_GAIN, default="1X"): cv.enum(TCS34725_GAINS, upper=True), cv.Optional(CONF_GLASS_ATTENUATION_FACTOR, default=1.0): cv.float_range( min=1.0 ), } ) .extend(cv.polling_component_schema("60s")) .extend(i2c.i2c_device_schema(0x29)) ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await i2c.register_i2c_device(var, config) cg.add(var.set_integration_time(config[CONF_INTEGRATION_TIME])) cg.add(var.set_gain(config[CONF_GAIN])) cg.add(var.set_glass_attenuation_factor(config[CONF_GLASS_ATTENUATION_FACTOR])) if CONF_RED_CHANNEL in config: sens = await sensor.new_sensor(config[CONF_RED_CHANNEL]) cg.add(var.set_red_sensor(sens))
UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT DEPENDENCIES = ['i2c'] scd30_ns = cg.esphome_ns.namespace('scd30') SCD30Component = scd30_ns.class_('SCD30Component', cg.PollingComponent, i2c.I2CDevice) CONF_CO2 = 'co2' CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(SCD30Component), cv.Required(CONF_CO2): sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_PERIODIC_TABLE_CO2, 0), cv.Required(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1), cv.Required(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1), }).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x61)) 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_CO2 in config: sens = yield sensor.new_sensor(config[CONF_CO2]) cg.add(var.set_co2_sensor(sens)) if CONF_HUMIDITY in config: sens = yield sensor.new_sensor(config[CONF_HUMIDITY]) cg.add(var.set_humidity_sensor(sens))
BH1750Sensor = bh1750_ns.class_("BH1750Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice) CONF_MEASUREMENT_TIME = "measurement_time" CONFIG_SCHEMA = (sensor.sensor_schema( BH1750Sensor, unit_of_measurement=UNIT_LUX, accuracy_decimals=1, device_class=DEVICE_CLASS_ILLUMINANCE, state_class=STATE_CLASS_MEASUREMENT, ).extend({ cv.Optional(CONF_RESOLUTION, default=0.5): cv.enum(BH1750_RESOLUTIONS, float=True), cv.Optional(CONF_MEASUREMENT_DURATION, default=69): cv.int_range(min=31, max=254), cv.Optional(CONF_MEASUREMENT_TIME): cv.invalid( "The 'measurement_time' option has been replaced with 'measurement_duration' in 1.18.0" ), }).extend(cv.polling_component_schema("60s")).extend( i2c.i2c_device_schema(0x23))) async def to_code(config): var = await sensor.new_sensor(config) await cg.register_component(var, config) await i2c.register_i2c_device(var, config) cg.add(var.set_resolution(config[CONF_RESOLUTION])) cg.add(var.set_measurement_duration(config[CONF_MEASUREMENT_DURATION]))
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import i2c from esphome.const import CONF_ID DEPENDENCIES = ["i2c"] AUTO_LOAD = ["sensor", "voltage_sampler"] MULTI_CONF = True ads1115_ns = cg.esphome_ns.namespace("ads1115") ADS1115Component = ads1115_ns.class_("ADS1115Component", cg.Component, i2c.I2CDevice) CONF_CONTINUOUS_MODE = "continuous_mode" CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(ADS1115Component), cv.Optional(CONF_CONTINUOUS_MODE, default=False): cv.boolean, }).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(None))) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield i2c.register_i2c_device(var, config) cg.add(var.set_continuous_mode(config[CONF_CONTINUOUS_MODE]))