"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,