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]))
