"BH1750Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice
)
CONF_MEASUREMENT_TIME = "measurement_time"
CONFIG_SCHEMA = (
sensor.sensor_schema(
unit_of_measurement=UNIT_LUX,
accuracy_decimals=1,
device_class=DEVICE_CLASS_ILLUMINANCE,
state_class=STATE_CLASS_MEASUREMENT,
)
.extend(
{
cv.GenerateID(): cv.declare_id(BH1750Sensor),
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):
)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(ATM90E32Component),
cv.Optional(CONF_PHASE_A): ATM90E32_PHASE_SCHEMA,
cv.Optional(CONF_PHASE_B): ATM90E32_PHASE_SCHEMA,
cv.Optional(CONF_PHASE_C): ATM90E32_PHASE_SCHEMA,
cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(
UNIT_HERTZ, ICON_CURRENT_AC, 1, DEVICE_CLASS_EMPTY
),
cv.Optional(CONF_CHIP_TEMPERATURE): sensor.sensor_schema(
UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE
),
cv.Required(CONF_LINE_FREQUENCY): cv.enum(LINE_FREQS, upper=True),
cv.Optional(CONF_CURRENT_PHASES, default="3"): cv.enum(
CURRENT_PHASES, upper=True
),
cv.Optional(CONF_GAIN_PGA, default="2X"): cv.enum(PGA_GAINS, upper=True),
}
)
.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)
"100KBPS": CanSpeed.CAN_100KBPS,
"125KBPS": CanSpeed.CAN_125KBPS,
"200KBPS": CanSpeed.CAN_200KBPS,
"250KBPS": CanSpeed.CAN_250KBPS,
"500KBPS": CanSpeed.CAN_500KBPS,
"1000KBPS": CanSpeed.CAN_1000KBPS,
}
CANBUS_SCHEMA = cv.Schema(
{
cv.GenerateID():
cv.declare_id(CanbusComponent),
cv.Required(CONF_CAN_ID):
cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_BIT_RATE, default="125KBPS"):
cv.enum(CAN_SPEEDS, upper=True),
cv.Optional(CONF_USE_EXTENDED_ID, default=False):
cv.boolean,
cv.Optional(CONF_ON_FRAME):
automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(CanbusTrigger),
cv.Required(CONF_CAN_ID):
cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_CAN_ID_MASK, default=0x1FFFFFFF):
cv.int_range(min=0, max=0x1FFFFFFF),
cv.Optional(CONF_USE_EXTENDED_ID, default=False):
cv.boolean,
cv.Optional(CONF_REMOTE_TRANSMISSION_REQUEST):
cv.boolean,
@automation.register_action('fan.turn_off', TurnOffAction, FAN_ACTION_SCHEMA)
def fan_turn_off_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('fan.turn_on', TurnOnAction,
maybe_simple_id({
cv.Required(CONF_ID):
cv.use_id(FanState),
cv.Optional(CONF_OSCILLATING):
cv.templatable(cv.boolean),
cv.Optional(CONF_SPEED):
cv.templatable(cv.enum(FAN_SPEEDS,
upper=True)),
}))
def fan_turn_on_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_OSCILLATING in config:
template_ = yield cg.templatable(config[CONF_OSCILLATING], args, bool)
cg.add(var.set_oscillating(template_))
if CONF_SPEED in config:
template_ = yield cg.templatable(config[CONF_SPEED], args, FanSpeed)
cg.add(var.set_speed(template_))
yield var
@coroutine_with_priority(100.0)
def to_code(config):
STATE_CLASS_MEASUREMENT,
STATE_CLASS_TOTAL_INCREASING,
UNIT_PULSES_PER_MINUTE,
UNIT_PULSES,
)
from esphome.core import CORE
pulse_counter_ns = cg.esphome_ns.namespace("pulse_counter")
PulseCounterCountMode = pulse_counter_ns.enum("PulseCounterCountMode")
COUNT_MODES = {
"DISABLE": PulseCounterCountMode.PULSE_COUNTER_DISABLE,
"INCREMENT": PulseCounterCountMode.PULSE_COUNTER_INCREMENT,
"DECREMENT": PulseCounterCountMode.PULSE_COUNTER_DECREMENT,
}
COUNT_MODE_SCHEMA = cv.enum(COUNT_MODES, upper=True)
PulseCounterSensor = pulse_counter_ns.class_("PulseCounterSensor",
sensor.Sensor,
cg.PollingComponent)
def validate_internal_filter(value):
value = cv.positive_time_period_microseconds(value)
if CORE.is_esp32:
if value.total_microseconds > 13:
raise cv.Invalid("Maximum internal filter value for ESP32 is 13us")
return value
return value
'SI7021': DHTModel.DHT_MODEL_SI7021,
'DHT22_TYPE2': DHTModel.DHT_MODEL_DHT22_TYPE2,
}
DHT = dht_ns.class_('DHT', cg.PollingComponent)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(DHT),
cv.Required(CONF_PIN):
pins.gpio_input_pin_schema,
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0),
cv.Optional(CONF_MODEL, default='auto detect'):
cv.enum(DHT_MODELS, upper=True, space='_'),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
pin = yield gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
if CONF_TEMPERATURE in config:
sens = yield sensor.new_sensor(config[CONF_TEMPERATURE])
cg.add(var.set_temperature_sensor(sens))
if CONF_HUMIDITY in config:
sens = yield sensor.new_sensor(config[CONF_HUMIDITY])
DEVICE_CLASS_SIGNAL_STRENGTH,
DEVICE_CLASS_SULPHUR_DIOXIDE,
DEVICE_CLASS_TEMPERATURE,
DEVICE_CLASS_TIMESTAMP,
DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
DEVICE_CLASS_VOLTAGE,
]
sensor_ns = cg.esphome_ns.namespace("sensor")
StateClasses = sensor_ns.enum("StateClass")
STATE_CLASSES = {
"": StateClasses.STATE_CLASS_NONE,
"measurement": StateClasses.STATE_CLASS_MEASUREMENT,
"total_increasing": StateClasses.STATE_CLASS_TOTAL_INCREASING,
}
validate_state_class = cv.enum(STATE_CLASSES, lower=True, space="_")
IS_PLATFORM_COMPONENT = True
def validate_send_first_at(value):
send_first_at = value.get(CONF_SEND_FIRST_AT)
send_every = value[CONF_SEND_EVERY]
if send_first_at is not None and send_first_at > send_every:
raise cv.Invalid(
f"send_first_at must be smaller than or equal to send_every! {send_first_at} <= {send_every}"
)
return value
FILTER_REGISTRY = Registry()
CONF_INVERT_COLORS = "invert_colors"
SPIST7735 = st7735_ns.class_(
"ST7735", cg.PollingComponent, display.DisplayBuffer, spi.SPIDevice
)
ST7735Model = st7735_ns.enum("ST7735Model")
MODELS = {
"INITR_GREENTAB": ST7735Model.ST7735_INITR_GREENTAB,
"INITR_REDTAB": ST7735Model.ST7735_INITR_REDTAB,
"INITR_BLACKTAB": ST7735Model.ST7735_INITR_BLACKTAB,
"INITR_MINI160X80": ST7735Model.ST7735_INITR_MINI_160X80,
"INITR_18BLACKTAB": ST7735Model.ST7735_INITR_18BLACKTAB,
"INITR_18REDTAB": ST7735Model.ST7735_INITR_18REDTAB,
}
ST7735_MODEL = cv.enum(MODELS, upper=True, space="_")
ST7735_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend(
{
cv.Required(CONF_MODEL): ST7735_MODEL,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
}
).extend(cv.polling_component_schema("1s"))
CONFIG_SCHEMA = cv.All(
ST7735_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(SPIST7735),
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_DEVICE_WIDTH): cv.int_,
CONF_WRITE_LAMBDA,
)
DEPENDENCIES = ["modbus_controller"]
CODEOWNERS = ["@martgras"]
ModbusSwitch = modbus_controller_ns.class_("ModbusSwitch", cg.Component,
switch.Switch, SensorItem)
CONFIG_SCHEMA = cv.All(
switch.SWITCH_SCHEMA.extend(
cv.COMPONENT_SCHEMA).extend(ModbusItemBaseSchema).extend({
cv.GenerateID():
cv.declare_id(ModbusSwitch),
cv.Optional(CONF_REGISTER_TYPE):
cv.enum(MODBUS_REGISTER_TYPE),
cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False):
cv.boolean,
cv.Optional(CONF_WRITE_LAMBDA):
cv.returning_lambda,
}),
validate_modbus_register,
)
async def to_code(config):
byte_offset, _ = modbus_calc_properties(config)
var = cg.new_Pvariable(
config[CONF_ID],
config[CONF_REGISTER_TYPE],
config[CONF_ADDRESS],
2: TM1651Display.TM1651_BRIGHTNESS_MEDIUM,
3: TM1651Display.TM1651_BRIGHTNESS_HIGH,
}
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID(): cv.declare_id(TM1651Display),
cv.Required(CONF_CLK_PIN): pins.internal_gpio_output_pin_schema,
cv.Required(CONF_DIO_PIN): pins.internal_gpio_output_pin_schema,
}),
cv.only_with_arduino,
)
validate_level_percent = cv.All(cv.int_range(min=0, max=100))
validate_level = cv.All(cv.int_range(min=0, max=7))
validate_brightness = cv.enum(TM1651_BRIGHTNESS_OPTIONS, int=True)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
clk_pin = await cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk_pin))
dio_pin = await cg.gpio_pin_expression(config[CONF_DIO_PIN])
cg.add(var.set_dio_pin(dio_pin))
# https://platformio.org/lib/show/6865/TM1651
cg.add_library("freekode/TM1651", "1.0.1")
CONF_TEMP_OFFSET = 'temperature_offset'
CONF_IAQ_MODE = 'iaq_mode'
CONF_STATE_SAVE_INTERVAL = 'state_save_interval'
bme680_bsec_ns = cg.esphome_ns.namespace('bme680_bsec')
BME680IAQMode = bme680_bsec_ns.enum('BME680IAQMode')
IAQ_MODE_OPTIONS = {
'STATIC': BME680IAQMode.BME680_IAQ_MODE_STATIC,
'MOBILE': BME680IAQMode.BME680_IAQ_MODE_MOBILE,
}
BME680BSECComponent = bme680_bsec_ns.class_('BME680BSECComponent', cg.Component, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(BME680BSECComponent),
cv.Optional(CONF_TEMP_OFFSET, default=0): cv.float_range(min=-100, max=100),
cv.Optional(CONF_IAQ_MODE, default='STATIC'):
cv.enum(IAQ_MODE_OPTIONS, upper=True),
cv.Optional(CONF_STATE_SAVE_INTERVAL, default='6hours'): cv.positive_time_period_minutes,
}).extend(i2c.i2c_device_schema(0x76))
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_temperature_offset(config[CONF_TEMP_OFFSET]))
cg.add(var.set_iaq_mode(config[CONF_IAQ_MODE]))
cg.add(var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL]))
CONF_TOOL_INDEX = "tool_index"
HEATER_ELEMENTS = {
"TOOL": ClimateToken.TOOL,
"BED": ClimateToken.BED,
"CHAMBER": ClimateToken.CHAMBER,
}
CONFIG_SCHEMA = (
climate.CLIMATE_SCHEMA
.extend(
{
cv.GenerateID(CONF_ID): cv.declare_id(GCodeClimate),
cv.GenerateID(GCodeSender.CONF_GCODE_SENDER): cv.use_id(GCodeSender.GCodeSenderComponent),
cv.Required(CONF_HEATER_ELEMENTS): cv.enum(
HEATER_ELEMENTS, upper=True
),
cv.Optional(CONF_TOOL_INDEX, default=0): cv.positive_int,
}
)
.extend(GCodeQueue.GCODE_ANALYZER_SCHEMA)
.extend(cv.COMPONENT_SCHEMA)
)
def to_code(config):
sender = yield cg.get_variable(config[GCodeSender.CONF_GCODE_SENDER])
var = cg.new_Pvariable(config[CONF_ID], sender, config[CONF_HEATER_ELEMENTS], config[CONF_TOOL_INDEX])
yield cg.register_component(var, config)
yield GCodeQueue.register_gcode_analyzer(var, config)
yield climate.register_climate(var, config)
def validate_integration_time(value):
value = cv.positive_time_period_milliseconds(value).total_milliseconds
return cv.enum(INTEGRATION_TIMES, int=True)(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(
TSL2561Sensor,
unit_of_measurement=UNIT_LUX,
accuracy_decimals=1,
device_class=DEVICE_CLASS_ILLUMINANCE,
state_class=STATE_CLASS_MEASUREMENT,
).extend({
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)))
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_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]))
"8MHZ": CanClock.MCP_8MHZ,
"16MHZ": CanClock.MCP_16MHZ,
"20MHZ": CanClock.MCP_20MHZ,
}
MCP_MODE = {
"NORMAL": McpMode.CANCTRL_REQOP_NORMAL,
"LOOPBACK": McpMode.CANCTRL_REQOP_LOOPBACK,
"LISTENONLY": McpMode.CANCTRL_REQOP_LISTENONLY,
}
CONFIG_SCHEMA = canbus.CANBUS_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(mcp2515),
cv.Optional(CONF_CLOCK, default="8MHZ"):
cv.enum(CAN_CLOCK, upper=True),
cv.Optional(CONF_MODE, default="NORMAL"):
cv.enum(MCP_MODE, upper=True),
}).extend(spi.spi_device_schema(True))
def to_code(config):
rhs = mcp2515.new()
var = cg.Pvariable(config[CONF_ID], rhs)
yield canbus.register_canbus(var, config)
if CONF_CLOCK in config:
canclock = CAN_CLOCK[config[CONF_CLOCK]]
cg.add(var.set_mcp_clock(canclock))
if CONF_MODE in config:
mode = MCP_MODE[config[CONF_MODE]]
cg.add(var.set_mcp_mode(mode))
f"between {mech_min_energy} Wh and {max_energy} Wh"
)
return config
validate_energy = cv.float_with_unit("energy", "(Wh|WH|wh)?", optional_unit=True)
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(CS5460AComponent),
cv.Optional(CONF_SAMPLES, default=4000): cv.int_range(min=1, max=0xFFFFFF),
cv.Optional(CONF_PHASE_OFFSET, default=0): cv.int_range(min=-64, max=63),
cv.Optional(CONF_PGA_GAIN, default="10X"): cv.enum(
PGA_GAIN_OPTIONS, upper=True
),
cv.Optional(CONF_CURRENT_GAIN, default=0.001): cv.negative_one_to_one_float,
cv.Optional(CONF_VOLTAGE_GAIN, default=0.001): cv.zero_to_one_float,
cv.Optional(CONF_CURRENT_HPF, default=True): cv.boolean,
cv.Optional(CONF_VOLTAGE_HPF, default=True): cv.boolean,
cv.Optional(CONF_PULSE_ENERGY, default=10.0): validate_energy,
cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
unit_of_measurement=UNIT_VOLT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_VOLTAGE,
),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=1,
device_class=DEVICE_CLASS_CURRENT,
SAMPLE_RATE_OPTIONS = {
"LP": SampleRate.SAMPLE_RATE_LP,
"ULP": SampleRate.SAMPLE_RATE_ULP,
}
BME680BSECComponent = bme680_bsec_ns.class_("BME680BSECComponent",
cg.Component, i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID():
cv.declare_id(BME680BSECComponent),
cv.Optional(CONF_TEMPERATURE_OFFSET, default=0):
cv.temperature,
cv.Optional(CONF_IAQ_MODE, default="STATIC"):
cv.enum(IAQ_MODE_OPTIONS, upper=True),
cv.Optional(CONF_SAMPLE_RATE, default="LP"):
cv.enum(SAMPLE_RATE_OPTIONS, upper=True),
cv.Optional(CONF_STATE_SAVE_INTERVAL, default="6hours"):
cv.positive_time_period_minutes,
},
cv.only_with_arduino,
).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)
cg.add(var.set_temperature_offset(config[CONF_TEMPERATURE_OFFSET]))
@automation.register_action('fan.toggle', ToggleAction, FAN_ACTION_SCHEMA)
def fan_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('fan.turn_off', TurnOffAction, FAN_ACTION_SCHEMA)
def fan_turn_off_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
@automation.register_action('fan.turn_on', TurnOnAction, maybe_simple_id({
cv.Required(CONF_ID): cv.use_id(FanState),
cv.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean),
cv.Optional(CONF_SPEED): cv.templatable(cv.enum(FAN_SPEEDS, upper=True)),
}))
def fan_turn_on_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
if CONF_OSCILLATING in config:
template_ = yield cg.templatable(config[CONF_OSCILLATING], args, bool)
cg.add(var.set_oscillating(template_))
if CONF_SPEED in config:
template_ = yield cg.templatable(config[CONF_SPEED], args, FanSpeed)
cg.add(var.set_speed(template_))
yield var
@coroutine_with_priority(100.0)
def to_code(config):
CONF_BREATH_VOC_EQUIVALENT,
]
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_BME680_BSEC_ID):
cv.use_id(BME680BSECComponent),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(
UNIT_CELSIUS,
ICON_THERMOMETER,
1,
DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT,
).extend({
cv.Optional(CONF_SAMPLE_RATE):
cv.enum(SAMPLE_RATE_OPTIONS, upper=True)
}),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(
UNIT_HECTOPASCAL,
ICON_GAUGE,
1,
DEVICE_CLASS_PRESSURE,
STATE_CLASS_MEASUREMENT,
).extend({
cv.Optional(CONF_SAMPLE_RATE):
cv.enum(SAMPLE_RATE_OPTIONS, upper=True)
}),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(
UNIT_PERCENT,
if conf in config:
if config[CONF_MODEL] not in models:
raise cv.Invalid(
f"{conf} is only available on {' and '.join(models)}, not {config[CONF_MODEL]}"
)
return config
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID():
cv.declare_id(HydreonRGxxComponent),
cv.Required(CONF_MODEL):
cv.enum(
RG_MODELS,
upper=True,
space="_",
),
cv.Optional(CONF_ACC):
sensor.sensor_schema(
unit_of_measurement=UNIT_MILLIMETERS,
accuracy_decimals=2,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_EVENT_ACC):
sensor.sensor_schema(
unit_of_measurement=UNIT_MILLIMETERS,
accuracy_decimals=2,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
if CONF_SLEEP_TIME in keypad and CONF_SCAN_TIME in keypad and CONF_DEBOUNCE_TIME in keypad:
cg.add(var.set_sleep_time(keypad[CONF_SLEEP_TIME]))
cg.add(var.set_scan_time(keypad[CONF_SCAN_TIME]))
cg.add(var.set_debounce_time(keypad[CONF_DEBOUNCE_TIME]))
CONF_SX1509 = 'sx1509'
CONF_SX1509_ID = 'sx1509_id'
SX1509_OUTPUT_PIN_SCHEMA = cv.Schema({
cv.Required(CONF_SX1509):
cv.use_id(SX1509Component),
cv.Required(CONF_NUMBER):
cv.int_,
cv.Optional(CONF_MODE, default="OUTPUT"):
cv.enum(SX1509_GPIO_MODES, upper=True),
cv.Optional(CONF_INVERTED, default=False):
cv.boolean,
})
SX1509_INPUT_PIN_SCHEMA = cv.Schema({
cv.Required(CONF_SX1509):
cv.use_id(SX1509Component),
cv.Required(CONF_NUMBER):
cv.int_,
cv.Optional(CONF_MODE, default="INPUT"):
cv.enum(SX1509_GPIO_MODES, upper=True),
cv.Optional(CONF_INVERTED, default=False):
cv.boolean,
})
CONFIG_SCHEMA = cv.All(
number.NUMBER_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(ModbusNumber),
cv.GenerateID(CONF_MODBUS_CONTROLLER_ID):
cv.use_id(ModbusController),
cv.Required(CONF_ADDRESS):
cv.positive_int,
cv.Optional(CONF_OFFSET, default=0):
cv.positive_int,
cv.Optional(CONF_BYTE_OFFSET):
cv.positive_int,
cv.Optional(CONF_BITMASK, default=0xFFFFFFFF):
cv.hex_uint32_t,
cv.Optional(CONF_VALUE_TYPE, default="U_WORD"):
cv.enum(SENSOR_VALUE_TYPE),
cv.Optional(CONF_REGISTER_COUNT, default=0):
cv.positive_int,
cv.Optional(CONF_SKIP_UPDATES, default=0):
cv.positive_int,
cv.Optional(CONF_FORCE_NEW_RANGE, default=False):
cv.boolean,
cv.Optional(CONF_LAMBDA):
cv.returning_lambda,
cv.Optional(CONF_WRITE_LAMBDA):
cv.returning_lambda,
cv.GenerateID():
cv.declare_id(ModbusNumber),
# 24 bits are the maximum value for fp32 before precison is lost
# 0x00FFFFFF = 16777215
cv.Optional(CONF_MAX_VALUE, default=16777215.0):
DEPENDENCIES = ["modbus_controller"]
CODEOWNERS = ["@martgras"]
ModbusBinarySensor = modbus_controller_ns.class_(
"ModbusBinarySensor", cg.Component, binary_sensor.BinarySensor, SensorItem
)
CONFIG_SCHEMA = cv.All(
binary_sensor.BINARY_SENSOR_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(ModbusBinarySensor),
cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
cv.Required(CONF_ADDRESS): cv.positive_int,
cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
cv.Optional(CONF_BITMASK, default=0x1): cv.hex_uint32_t,
cv.Optional(CONF_SKIP_UPDATES, default=0): cv.positive_int,
cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
cv.Optional(CONF_LAMBDA): cv.returning_lambda,
}
).extend(cv.COMPONENT_SCHEMA),
)
async def to_code(config):
byte_offset = 0
if CONF_OFFSET in config:
byte_offset = config[CONF_OFFSET]
return cv.only_on_esp8266(vcc)
return pins.analog_pin(value)
adc_ns = cg.esphome_ns.namespace("adc")
ADCSensor = adc_ns.class_("ADCSensor", sensor.Sensor, cg.PollingComponent,
voltage_sampler.VoltageSampler)
CONFIG_SCHEMA = (sensor.sensor_schema(
UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE).extend({
cv.GenerateID():
cv.declare_id(ADCSensor),
cv.Required(CONF_PIN):
validate_adc_pin,
cv.SplitDefault(CONF_ATTENUATION, esp32="0db"):
cv.All(cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=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)
if config[CONF_PIN] == "VCC":
cg.add_define("USE_ADC_SENSOR_VCC")
else:
cg.add(var.set_pin(config[CONF_PIN]))
if CONF_ATTENUATION in config:
cg.add(var.set_attenuation(config[CONF_ATTENUATION]))
CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
CONF_ESP32_EXT1_WAKEUP = 'esp32_ext1_wakeup'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(DeepSleepComponent),
cv.Optional(CONF_RUN_DURATION):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_SLEEP_DURATION):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_WAKEUP_PIN):
cv.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema,
validate_pin_number),
cv.Optional(CONF_WAKEUP_PIN_MODE):
cv.All(cv.only_on_esp32, cv.enum(WAKEUP_PIN_MODES), upper=True),
cv.Optional(CONF_ESP32_EXT1_WAKEUP):
cv.All(
cv.only_on_esp32,
cv.Schema({
cv.Required(CONF_PINS):
cv.ensure_list(pins.shorthand_input_pin, validate_pin_number),
cv.Required(CONF_MODE):
cv.enum(EXT1_WAKEUP_MODES, upper=True),
})),
cv.Optional(CONF_RUN_CYCLES):
cv.invalid("The run_cycles option has been removed in 1.11.0 as "
"it was essentially the same as a run_duration of 0s."
"Please use run_duration now.")
}).extend(cv.COMPONENT_SCHEMA)
cv.Optional(CONF_PORT, default=1883):
cv.port,
cv.Optional(CONF_USERNAME, default=""):
cv.string,
cv.Optional(CONF_PASSWORD, default=""):
cv.string,
cv.Optional(CONF_CLIENT_ID):
cv.string,
cv.Optional(CONF_DISCOVERY, default=True):
cv.Any(cv.boolean, cv.one_of("CLEAN", upper=True)),
cv.Optional(CONF_DISCOVERY_RETAIN, default=True):
cv.boolean,
cv.Optional(CONF_DISCOVERY_PREFIX, default="homeassistant"):
cv.publish_topic,
cv.Optional(CONF_DISCOVERY_UNIQUE_ID_GENERATOR, default="legacy"):
cv.enum(MQTT_DISCOVERY_UNIQUE_ID_GENERATOR_OPTIONS),
cv.Optional(CONF_DISCOVERY_OBJECT_ID_GENERATOR, default="none"):
cv.enum(MQTT_DISCOVERY_OBJECT_ID_GENERATOR_OPTIONS),
cv.Optional(CONF_USE_ABBREVIATIONS, default=True):
cv.boolean,
cv.Optional(CONF_BIRTH_MESSAGE):
MQTT_MESSAGE_SCHEMA,
cv.Optional(CONF_WILL_MESSAGE):
MQTT_MESSAGE_SCHEMA,
cv.Optional(CONF_SHUTDOWN_MESSAGE):
MQTT_MESSAGE_SCHEMA,
cv.Optional(CONF_TOPIC_PREFIX, default=lambda: CORE.name):
cv.publish_topic,
cv.Optional(CONF_LOG_TOPIC):
cv.Any(
None,
MAX31865ConfigFilter = max31865_ns.enum('MAX31865ConfigFilter')
FILTER = {
'50HZ': MAX31865ConfigFilter.FILTER_50HZ,
'60HZ': MAX31865ConfigFilter.FILTER_60HZ,
}
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 2).extend(
{
cv.GenerateID():
cv.declare_id(MAX31865Sensor),
cv.Required(CONF_REFERENCE_RESISTANCE):
cv.All(cv.resistance, cv.Range(min=100, max=10000)),
cv.Required(CONF_RTD_NOMINAL_RESISTANCE):
cv.All(cv.resistance, cv.Range(min=100, max=1000)),
cv.Optional(CONF_MAINS_FILTER, default='60HZ'):
cv.enum(FILTER, upper=True, space=''),
cv.Optional(CONF_RTD_WIRES, default=4):
cv.int_range(min=2, max=4),
}).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_reference_resistance(config[CONF_REFERENCE_RESISTANCE]))
cg.add(var.set_nominal_resistance(config[CONF_RTD_NOMINAL_RESISTANCE]))
cg.add(var.set_filter(config[CONF_MAINS_FILTER]))
cg.add(var.set_num_rtd_wires(config[CONF_RTD_WIRES]))
if CONF_FILE in config:
template_ = yield cg.templatable(config[CONF_FILE], args, float)
cg.add(var.set_file(template_))
if CONF_LOOP in config:
template_ = yield cg.templatable(config[CONF_LOOP], args, float)
cg.add(var.set_loop(template_))
yield var
@automation.register_action(
"dfplayer.set_device",
SetDeviceAction,
cv.maybe_simple_value(
{
cv.GenerateID(): cv.use_id(DFPlayer),
cv.Required(CONF_DEVICE): cv.enum(DEVICE, upper=True),
},
key=CONF_DEVICE,
),
)
def dfplayer_set_device_to_code(config, action_id, template_arg, args):
var = cg.new_Pvariable(action_id, template_arg)
yield cg.register_parented(var, config[CONF_ID])
template_ = yield cg.templatable(config[CONF_DEVICE], args, Device)
cg.add(var.set_device(template_))
yield var
@automation.register_action(
"dfplayer.set_volume",
SetVolumeAction,
CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend({
cv.Required(CONF_ID):
cv.declare_id(ULN2003),
cv.Required(CONF_PIN_A):
pins.gpio_output_pin_schema,
cv.Required(CONF_PIN_B):
pins.gpio_output_pin_schema,
cv.Required(CONF_PIN_C):
pins.gpio_output_pin_schema,
cv.Required(CONF_PIN_D):
pins.gpio_output_pin_schema,
cv.Optional(CONF_SLEEP_WHEN_DONE, default=False):
cv.boolean,
cv.Optional(CONF_STEP_MODE, default='FULL_STEP'):
cv.enum(STEP_MODES, upper=True, space='_')
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield stepper.register_stepper(var, config)
pin_a = yield cg.gpio_pin_expression(config[CONF_PIN_A])
cg.add(var.set_pin_a(pin_a))
pin_b = yield cg.gpio_pin_expression(config[CONF_PIN_B])
cg.add(var.set_pin_b(pin_b))
pin_c = yield cg.gpio_pin_expression(config[CONF_PIN_C])
cg.add(var.set_pin_c(pin_c))
pin_d = yield cg.gpio_pin_expression(config[CONF_PIN_D])
}
def validate_pmsx003_sensors(value):
for key, types in SENSORS_TO_TYPE.items():
if key in value and value[CONF_TYPE] not in types:
raise cv.Invalid("{} does not have {} sensor!".format(
value[CONF_TYPE], key))
return value
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(PMSX003Component),
cv.Required(CONF_TYPE):
cv.enum(PMSX003_TYPES, upper=True),
cv.Optional(CONF_PM_1_0):
sensor.sensor_schema(
UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON,
0,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_PM_2_5):
sensor.sensor_schema(
UNIT_MICROGRAMS_PER_CUBIC_METER,
ICON_CHEMICAL_WEAPON,
0,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
