import esphome.config_validation as cv
from esphome.components import sensor, spi
from esphome.const import CONF_ID, CONF_MAINS_FILTER, ICON_THERMOMETER, UNIT_CELSIUS
max31856_ns = cg.esphome_ns.namespace('max31856')
MAX31856Sensor = max31856_ns.class_('MAX31856Sensor', sensor.Sensor,
cg.PollingComponent, spi.SPIDevice)
MAX31865ConfigFilter = max31856_ns.enum('MAX31856ConfigFilter')
FILTER = {
'50HZ': MAX31865ConfigFilter.FILTER_50HZ,
'60HZ': MAX31865ConfigFilter.FILTER_60HZ,
}
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend(
{
cv.GenerateID():
cv.declare_id(MAX31856Sensor),
cv.Optional(CONF_MAINS_FILTER, default='60HZ'):
cv.enum(FILTER, upper=True, space=''),
}).extend(cv.polling_component_schema('60s')).extend(
spi.spi_device_schema())
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
yield sensor.register_sensor(var, config)
cg.add(var.set_filter(config[CONF_MAINS_FILTER]))
)
return config
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(
NextionSensor,
accuracy_decimals=2,
)
.extend(
{
cv.Optional(CONF_PRECISION, default=0): cv.int_range(min=0, max=8),
cv.Optional(CONF_WAVE_CHANNEL_ID): CheckWaveID,
cv.Optional(CONF_COMPONENT_ID): cv.uint8_t,
cv.Optional(CONF_WAVE_MAX_LENGTH, default=255): cv.int_range(
min=1, max=1024
),
cv.Optional(CONF_WAVE_MAX_VALUE, default=100): cv.int_range(
min=1, max=1024
),
cv.Optional(CONF_WAVEFORM_SEND_LAST_VALUE, default=True): cv.boolean,
}
)
.extend(CONFIG_SENSOR_COMPONENT_SCHEMA)
.extend(cv.polling_component_schema("never")),
cv.has_exactly_one_key(CONF_COMPONENT_ID, CONF_COMPONENT_NAME, CONF_VARIABLE_NAME),
_validate,
)
async def to_code(config):
CONF_ID,
CONF_REFERENCE_TEMPERATURE,
DEVICE_CLASS_TEMPERATURE,
ICON_EMPTY,
UNIT_CELSIUS,
)
max31855_ns = cg.esphome_ns.namespace("max31855")
MAX31855Sensor = max31855_ns.class_("MAX31855Sensor", sensor.Sensor,
cg.PollingComponent, spi.SPIDevice)
CONFIG_SCHEMA = (sensor.sensor_schema(
UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE).extend({
cv.GenerateID():
cv.declare_id(MAX31855Sensor),
cv.Optional(CONF_REFERENCE_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 2,
DEVICE_CLASS_TEMPERATURE),
}).extend(cv.polling_component_schema("60s")).extend(
spi.spi_device_schema()))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
yield sensor.register_sensor(var, config)
if CONF_REFERENCE_TEMPERATURE in config:
tc_ref = yield sensor.new_sensor(config[CONF_REFERENCE_TEMPERATURE])
cg.add(var.set_reference_sensor(tc_ref))
raise cv.Invalid("Maximum timeout can not be greater then 60 seconds")
return value
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(
UNIT_METER,
ICON_ARROW_EXPAND_VERTICAL,
2,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
).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,
)
async def to_code(config):
UNIT_PERCENT,
)
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_EMPTY, 1, DEVICE_CLASS_TEMPERATURE
),
cv.Required(CONF_HUMIDITY): sensor.sensor_schema(
UNIT_PERCENT, ICON_EMPTY, 1, DEVICE_CLASS_HUMIDITY
),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(i2c.i2c_device_schema(0x40))
)
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)
ccs811_ns = cg.esphome_ns.namespace("ccs811")
CCS811Component = ccs811_ns.class_("CCS811Component", cg.PollingComponent,
i2c.I2CDevice)
CONF_ECO2 = "eco2"
CONF_BASELINE = "baseline"
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(CCS811Component),
cv.Required(CONF_ECO2):
sensor.sensor_schema(
UNIT_PARTS_PER_MILLION,
ICON_MOLECULE_CO2,
0,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
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),
CONF_LIGHTNING_ENERGY,
DEVICE_CLASS_EMPTY,
UNIT_KILOMETER,
UNIT_EMPTY,
ICON_SIGNAL_DISTANCE_VARIANT,
ICON_FLASH,
)
from . import AS3935, CONF_AS3935_ID
DEPENDENCIES = ["as3935"]
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_AS3935_ID):
cv.use_id(AS3935),
cv.Optional(CONF_DISTANCE):
sensor.sensor_schema(UNIT_KILOMETER, ICON_SIGNAL_DISTANCE_VARIANT, 1,
DEVICE_CLASS_EMPTY),
cv.Optional(CONF_LIGHTNING_ENERGY):
sensor.sensor_schema(UNIT_EMPTY, ICON_FLASH, 1, DEVICE_CLASS_EMPTY),
}).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
hub = await cg.get_variable(config[CONF_AS3935_ID])
if CONF_DISTANCE in config:
conf = config[CONF_DISTANCE]
distance_sensor = await sensor.new_sensor(conf)
cg.add(hub.set_distance_sensor(distance_sensor))
if CONF_LIGHTNING_ENERGY in config:
conf = config[CONF_LIGHTNING_ENERGY]
SENSOR_MAP_TYPES = {
CONF_GROUP: SensorMapType.BINARY_SENSOR_MAP_TYPE_GROUP,
}
entry = {
cv.Required(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_VALUE): cv.float_,
}
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_GROUP:
sensor.sensor_schema(UNIT_EMPTY, ICON_CHECK_CIRCLE_OUTLINE, 0).extend({
cv.GenerateID():
cv.declare_id(BinarySensorMap),
cv.Required(CONF_CHANNELS):
cv.All(cv.ensure_list(entry), cv.Length(min=1)),
}),
},
lower=True)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
constant = SENSOR_MAP_TYPES[config[CONF_TYPE]]
cg.add(var.set_sensor_type(constant))
for ch in config[CONF_CHANNELS]:
DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_gcls002_ns = cg.esphome_ns.namespace("xiaomi_gcls002")
XiaomiGCLS002 = xiaomi_gcls002_ns.class_("XiaomiGCLS002",
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(XiaomiGCLS002),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1,
DEVICE_CLASS_TEMPERATURE),
cv.Optional(CONF_MOISTURE):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0,
DEVICE_CLASS_EMPTY),
cv.Optional(CONF_ILLUMINANCE):
sensor.sensor_schema(UNIT_LUX, ICON_EMPTY, 0, DEVICE_CLASS_ILLUMINANCE),
cv.Optional(CONF_CONDUCTIVITY):
sensor.sensor_schema(UNIT_MICROSIEMENS_PER_CENTIMETER, ICON_FLOWER, 0,
DEVICE_CLASS_EMPTY),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield esp32_ble_tracker.register_ble_device(var, config)
raise cv.Invalid(f'invalid gain "{value}"')
return cv.enum(GAIN)(value)
ADS1115Sensor = ads1115_ns.class_("ADS1115Sensor", sensor.Sensor,
cg.PollingComponent,
voltage_sampler.VoltageSampler)
CONF_ADS1115_ID = "ads1115_id"
CONFIG_SCHEMA = (sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 3,
DEVICE_CLASS_VOLTAGE).extend({
cv.GenerateID():
cv.declare_id(ADS1115Sensor),
cv.GenerateID(CONF_ADS1115_ID):
cv.use_id(ADS1115Component),
cv.Required(CONF_MULTIPLEXER):
cv.enum(MUX, upper=True, space="_"),
cv.Required(CONF_GAIN):
validate_gain,
}).extend(
cv.polling_component_schema("60s")))
def to_code(config):
paren = yield cg.get_variable(config[CONF_ADS1115_ID])
var = cg.new_Pvariable(config[CONF_ID], paren)
yield sensor.register_sensor(var, config)
yield cg.register_component(var, config)
cg.add(var.set_multiplexer(config[CONF_MULTIPLEXER]))
cg.add(var.set_gain(config[CONF_GAIN]))
UNIT_PARTS_PER_MILLION, UNIT_CELSIUS, UNIT_PERCENT, \
ICON_MOLECULE_CO2, ICON_THERMOMETER, ICON_WATER_PERCENT
from esphome.cpp_helpers import gpio_pin_expression
zyaura_ns = cg.esphome_ns.namespace('zyaura')
ZyAuraSensor = zyaura_ns.class_('ZyAuraSensor', cg.PollingComponent)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(ZyAuraSensor),
cv.Required(CONF_CLOCK_PIN):
cv.All(pins.internal_gpio_input_pin_schema, pins.validate_has_interrupt),
cv.Required(CONF_DATA_PIN):
cv.All(pins.internal_gpio_input_pin_schema, pins.validate_has_interrupt),
cv.Optional(CONF_CO2):
sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_MOLECULE_CO2, 0),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
pin_clock = yield gpio_pin_expression(config[CONF_CLOCK_PIN])
cg.add(var.set_pin_clock(pin_clock))
pin_data = yield gpio_pin_expression(config[CONF_DATA_PIN])
cg.add(var.set_pin_data(pin_data))
ultrasonic_ns = cg.esphome_ns.namespace("ultrasonic")
UltrasonicSensorComponent = ultrasonic_ns.class_(
"UltrasonicSensorComponent", sensor.Sensor, cg.PollingComponent
)
CONFIG_SCHEMA = (
sensor.sensor_schema(
UltrasonicSensorComponent,
unit_of_measurement=UNIT_METER,
icon=ICON_ARROW_EXPAND_VERTICAL,
accuracy_decimals=2,
state_class=STATE_CLASS_MEASUREMENT,
)
.extend(
{
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,
}
)
.extend(cv.polling_component_schema("60s"))
)
async def to_code(config):
var = await sensor.new_sensor(config)
await cg.register_component(var, config)
DEPENDENCIES = ["i2c"]
CONF_ACCEL_X = "accel_x"
CONF_ACCEL_Y = "accel_y"
CONF_ACCEL_Z = "accel_z"
CONF_GYRO_X = "gyro_x"
CONF_GYRO_Y = "gyro_y"
CONF_GYRO_Z = "gyro_z"
mpu6050_ns = cg.esphome_ns.namespace("mpu6050")
MPU6050Component = mpu6050_ns.class_("MPU6050Component", cg.PollingComponent,
i2c.I2CDevice)
accel_schema = sensor.sensor_schema(
unit_of_measurement=UNIT_METER_PER_SECOND_SQUARED,
icon=ICON_BRIEFCASE_DOWNLOAD,
accuracy_decimals=2,
state_class=STATE_CLASS_MEASUREMENT,
)
gyro_schema = sensor.sensor_schema(
unit_of_measurement=UNIT_DEGREE_PER_SECOND,
icon=ICON_SCREEN_ROTATION,
accuracy_decimals=2,
state_class=STATE_CLASS_MEASUREMENT,
)
temperature_schema = sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
)
CONF_UPDATE_INTERVAL,
DEVICE_CLASS_TEMPERATURE,
ICON_EMPTY,
UNIT_CELSIUS,
)
DEPENDENCIES = ["i2c"]
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(UNIT_CELSIUS, ICON_EMPTY, 1,
DEVICE_CLASS_TEMPERATURE).extend({
cv.GenerateID():
cv.declare_id(TMP117Component),
}).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
STATE_CLASS_MEASUREMENT,
UNIT_CELSIUS,
)
max31855_ns = cg.esphome_ns.namespace("max31855")
MAX31855Sensor = max31855_ns.class_("MAX31855Sensor", sensor.Sensor,
cg.PollingComponent, spi.SPIDevice)
CONFIG_SCHEMA = (sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
).extend({
cv.GenerateID():
cv.declare_id(MAX31855Sensor),
cv.Optional(CONF_REFERENCE_TEMPERATURE):
sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=2,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
),
}).extend(cv.polling_component_schema("60s")).extend(spi.spi_device_schema()))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await spi.register_spi_device(var, config)
await sensor.register_sensor(var, config)
if CONF_REFERENCE_TEMPERATURE in config:
)
return value
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.Schema({
cv.Required(CONF_RISING_EDGE):
COUNT_MODE_SCHEMA,
cv.Required(CONF_FALLING_EDGE):
COUNT_MODE_SCHEMA,
}),
cv.Optional(CONF_INTERNAL_FILTER,
default='13us'):
validate_internal_filter,
}).extend(
cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_jqjcy01ym_ns = cg.esphome_ns.namespace("xiaomi_jqjcy01ym")
XiaomiJQJCY01YM = xiaomi_jqjcy01ym_ns.class_(
"XiaomiJQJCY01YM", esp32_ble_tracker.ESPBTDeviceListener, cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(XiaomiJQJCY01YM),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(
UNIT_CELSIUS,
ICON_EMPTY,
1,
DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(
UNIT_PERCENT,
ICON_EMPTY,
0,
DEVICE_CLASS_HUMIDITY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_FORMALDEHYDE):
sensor.sensor_schema(
UNIT_MILLIGRAMS_PER_CUBIC_METER,
ICON_FLASK_OUTLINE,
from esphome.components import sensor
from esphome.const import CONF_ID, UNIT_EMPTY, ICON_EMPTY
empty_compound_sensor_ns = cg.esphome_ns.namespace('empty_compound_sensor')
EmptyCompoundSensor = empty_compound_sensor_ns.class_('EmptyCompoundSensor',
cg.PollingComponent)
CONF_SENSOR1 = "sensor1"
CONF_SENSOR2 = "sensor2"
CONF_SENSOR3 = "sensor3"
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(EmptyCompoundSensor),
cv.Optional(CONF_SENSOR1):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 1).extend(),
cv.Optional(CONF_SENSOR2):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 1).extend(),
cv.Optional(CONF_SENSOR3):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 1).extend()
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
if CONF_SENSOR1 in config:
conf = config[CONF_SENSOR1]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_sensor1(sens))
import esphome.config_validation as cv
from esphome.components import i2c, sensor
from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
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_THERMOMETER, 2),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 2),
}).extend(cv.polling_component_schema('60s')).extend(
i2c.i2c_device_schema(0x38))
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_sensor(sens))
import esphome.config_validation as cv
from esphome import automation
from esphome.components import sensor
from esphome.const import (
CONF_ID,
CONF_LAMBDA,
CONF_STATE,
)
from .. import template_ns
TemplateSensor = template_ns.class_("TemplateSensor", sensor.Sensor,
cg.PollingComponent)
CONFIG_SCHEMA = (sensor.sensor_schema(
TemplateSensor,
accuracy_decimals=1,
).extend({
cv.Optional(CONF_LAMBDA): cv.returning_lambda,
}).extend(cv.polling_component_schema("60s")))
async def to_code(config):
var = await sensor.new_sensor(config)
await cg.register_component(var, config)
if CONF_LAMBDA in config:
template_ = await cg.process_lambda(
config[CONF_LAMBDA], [], return_type=cg.optional.template(float))
cg.add(var.set_template(template_))
@automation.register_action(
AUTO_LOAD = ["ruuvi_ble"]
ruuvitag_ns = cg.esphome_ns.namespace("ruuvitag")
RuuviTag = ruuvitag_ns.class_("RuuviTag",
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(RuuviTag),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
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,
),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(
unit_of_measurement=UNIT_HECTOPASCAL,
accuracy_decimals=2,
device_class=DEVICE_CLASS_PRESSURE,
state_class=STATE_CLASS_MEASUREMENT,
AUTO_LOAD = ["voltage_sampler"]
CODEOWNERS = ["@jesserockz"]
CONF_SAMPLE_DURATION = "sample_duration"
ct_clamp_ns = cg.esphome_ns.namespace("ct_clamp")
CTClampSensor = ct_clamp_ns.class_("CTClampSensor", sensor.Sensor,
cg.PollingComponent)
CONFIG_SCHEMA = (sensor.sensor_schema(
CTClampSensor,
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=2,
device_class=DEVICE_CLASS_CURRENT,
state_class=STATE_CLASS_MEASUREMENT,
).extend({
cv.Required(CONF_SENSOR):
cv.use_id(voltage_sampler.VoltageSampler),
cv.Optional(CONF_SAMPLE_DURATION, default="200ms"):
cv.positive_time_period_milliseconds,
}).extend(cv.polling_component_schema("60s")))
async def to_code(config):
var = await sensor.new_sensor(config)
await cg.register_component(var, config)
sens = await cg.get_variable(config[CONF_SENSOR])
cg.add(var.set_source(sens))
cg.add(var.set_sample_duration(config[CONF_SAMPLE_DURATION]))
ICON_EMPTY,
UNIT_CELSIUS,
UNIT_PERCENT,
)
DEPENDENCIES = ["i2c"]
sht3xd_ns = cg.esphome_ns.namespace("sht3xd")
SHT3XDComponent = sht3xd_ns.class_("SHT3XDComponent", cg.PollingComponent,
i2c.I2CDevice)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(SHT3XDComponent),
cv.Required(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1,
DEVICE_CLASS_TEMPERATURE),
cv.Required(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 1, DEVICE_CLASS_HUMIDITY),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x44)))
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))
DEPENDENCIES = ["i2c"]
CONF_CHANNEL_1 = "channel_1"
CONF_CHANNEL_2 = "channel_2"
CONF_CHANNEL_3 = "channel_3"
ina3221_ns = cg.esphome_ns.namespace("ina3221")
INA3221Component = ina3221_ns.class_(
"INA3221Component", cg.PollingComponent, i2c.I2CDevice
)
INA3221_CHANNEL_SCHEMA = cv.Schema(
{
cv.Optional(CONF_BUS_VOLTAGE): sensor.sensor_schema(
UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE, STATE_CLASS_MEASUREMENT
),
cv.Optional(CONF_SHUNT_VOLTAGE): sensor.sensor_schema(
UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE, STATE_CLASS_MEASUREMENT
),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(
UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT
),
cv.Optional(CONF_POWER): sensor.sensor_schema(
UNIT_WATT, ICON_EMPTY, 2, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1): cv.All(
cv.resistance, cv.Range(min=0.0, max=32.0)
),
}
)
from esphome.components import sensor
from esphome.const import (
CONF_ID,
CONF_PIN,
DEVICE_CLASS_EMPTY,
UNIT_PERCENT,
ICON_PERCENT,
)
duty_cycle_ns = cg.esphome_ns.namespace("duty_cycle")
DutyCycleSensor = duty_cycle_ns.class_("DutyCycleSensor", sensor.Sensor,
cg.PollingComponent)
CONFIG_SCHEMA = (sensor.sensor_schema(
UNIT_PERCENT, ICON_PERCENT, 1, DEVICE_CLASS_EMPTY).extend({
cv.GenerateID():
cv.declare_id(DutyCycleSensor),
cv.Required(CONF_PIN):
cv.All(pins.internal_gpio_input_pin_schema,
pins.validate_has_interrupt),
}).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))
ICON_EMPTY,
)
DEPENDENCIES = ["esp32_ble_tracker"]
ble_rssi_ns = cg.esphome_ns.namespace("ble_rssi")
BLERSSISensor = ble_rssi_ns.class_("BLERSSISensor", sensor.Sensor,
cg.Component,
esp32_ble_tracker.ESPBTDeviceListener)
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(
UNIT_DECIBEL, ICON_EMPTY, 0, DEVICE_CLASS_SIGNAL_STRENGTH).extend({
cv.GenerateID():
cv.declare_id(BLERSSISensor),
cv.Optional(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_SERVICE_UUID):
esp32_ble_tracker.bt_uuid,
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
cv.COMPONENT_SCHEMA),
cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID),
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield esp32_ble_tracker.register_ble_device(var, config)
yield sensor.register_sensor(var, config)
if CONF_MAC_ADDRESS in config:
"101ms": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_101MS,
"154ms": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_154MS,
"700ms": TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_700MS,
}
TCS34725Gain = tcs34725_ns.enum("TCS34725Gain")
TCS34725_GAINS = {
"1X": TCS34725Gain.TCS34725_GAIN_1X,
"4X": TCS34725Gain.TCS34725_GAIN_4X,
"16X": TCS34725Gain.TCS34725_GAIN_16X,
"60X": TCS34725Gain.TCS34725_GAIN_60X,
}
color_channel_schema = sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
icon=ICON_LIGHTBULB,
accuracy_decimals=1,
state_class=STATE_CLASS_MEASUREMENT,
)
color_temperature_schema = sensor.sensor_schema(
unit_of_measurement=UNIT_KELVIN,
icon=ICON_THERMOMETER,
accuracy_decimals=1,
state_class=STATE_CLASS_MEASUREMENT,
)
illuminance_schema = sensor.sensor_schema(
unit_of_measurement=UNIT_LUX,
accuracy_decimals=1,
device_class=DEVICE_CLASS_ILLUMINANCE,
state_class=STATE_CLASS_MEASUREMENT,
)
cg.PollingComponent)
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_SCALE, 0).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'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
dout_pin = yield cg.gpio_pin_expression(config[CONF_DOUT_PIN])
cg.add(var.set_dout_pin(dout_pin))
sck_pin = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_sck_pin(sck_pin))
CONF_INVERTER_STATUS = "inverter_status"
CONF_PV_ACTIVE_POWER = "pv_active_power"
CONF_INVERTER_MODULE_TEMP = "inverter_module_temp"
AUTO_LOAD = ["modbus"]
CODEOWNERS = ["@leeuwte"]
growatt_solar_ns = cg.esphome_ns.namespace("growatt_solar")
GrowattSolar = growatt_solar_ns.class_("GrowattSolar", cg.PollingComponent,
modbus.ModbusDevice)
PHASE_SENSORS = {
CONF_VOLTAGE:
sensor.sensor_schema(
unit_of_measurement=UNIT_VOLT,
accuracy_decimals=2,
device_class=DEVICE_CLASS_VOLTAGE,
),
CONF_CURRENT:
sensor.sensor_schema(
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=2,
device_class=DEVICE_CLASS_CURRENT,
state_class=STATE_CLASS_MEASUREMENT,
),
CONF_ACTIVE_POWER:
sensor.sensor_schema(
unit_of_measurement=UNIT_WATT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_POWER,
state_class=STATE_CLASS_MEASUREMENT,
CONF_BATTERY_LEVEL = 'battery_level'
CONF_LIGHT_LEVEL = 'light_level'
UNIT_KWH = 'kW/h'
UNIT_DM3 = 'dm3'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(iNodeMeterSensor),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_CONSTANT, default=1000):
cv.positive_not_null_int,
cv.Optional(CONF_AVG_RAW):
sensor.sensor_schema(UNIT_EMPTY, ICON_PULSE, 0),
cv.Optional(CONF_AVG_W):
sensor.sensor_schema(UNIT_WATT, ICON_CURRENT_AC, 2),
cv.Optional(CONF_AVG_DM3):
sensor.sensor_schema(UNIT_DM3, ICON_EMPTY, 2),
cv.Optional(CONF_TOTAL_RAW):
sensor.sensor_schema(UNIT_EMPTY, ICON_PULSE, 0),
cv.Optional(CONF_TOTAL_KWH):
sensor.sensor_schema(UNIT_KWH, ICON_FLASH, 2),
cv.Optional(CONF_TOTAL_DM3):
sensor.sensor_schema(UNIT_DM3, ICON_EMPTY, 2),
cv.Optional(CONF_BATTERY_LEVEL):
sensor.sensor_schema(UNIT_PERCENT, ICON_BATTERY, 0),
cv.Optional(CONF_LIGHT_LEVEL):
sensor.sensor_schema(UNIT_PERCENT, ICON_BRIGHTNESS_5, 0),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
