from esphome.const import CONF_EXTERNAL_VCC, CONF_LAMBDA, CONF_MODEL, CONF_RESET_PIN, \ CONF_BRIGHTNESS from . import st7735_ns DEPENDENCIES = ['spi'] ST7735 = st7735_ns.class_('ST7735', cg.PollingComponent, spi.SPIDevice) ST7735Ref = ST7735.operator('ref') CONFIG_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(ST7735), cv.Required(CONF_RESET_PIN): pins.gpio_output_pin_schema, cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema, cv.Required(CONF_CS_PIN): pins.gpio_output_pin_schema, cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage, }).extend(cv.polling_component_schema('1s')).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) dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN]) cg.add(var.set_dc_pin(dc)) reset = yield cg.gpio_pin_expression(config[CONF_RESET_PIN]) cg.add(var.set_reset_pin(reset)) if CONF_LAMBDA in config: lambda_ = yield cg.process_lambda(
BedjetHeatMode = bedjet_ns.enum("BedjetHeatMode") BEDJET_HEAT_MODES = { "heat": BedjetHeatMode.HEAT_MODE_HEAT, "extended": BedjetHeatMode.HEAT_MODE_EXTENDED, } CONFIG_SCHEMA = (climate.CLIMATE_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(Bedjet), cv.Optional(CONF_HEAT_MODE, default="heat"): cv.enum(BEDJET_HEAT_MODES, lower=True), cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock), cv.Optional(CONF_RECEIVE_TIMEOUT, default="0s"): cv.positive_time_period_milliseconds, }).extend(ble_client.BLE_CLIENT_SCHEMA).extend( cv.polling_component_schema("30s"))) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await climate.register_climate(var, config) await ble_client.register_ble_node(var, config) cg.add(var.set_heating_mode(config[CONF_HEAT_MODE])) if CONF_TIME_ID in config: time_ = await cg.get_variable(config[CONF_TIME_ID]) cg.add(var.set_time_id(time_)) if CONF_RECEIVE_TIMEOUT in config: cg.add(var.set_status_timeout(config[CONF_RECEIVE_TIMEOUT]))
{ cv.Optional( CONF_BINARY_SENSORS, default=[ { CONF_NAME: "Demo Basement Floor Wet", CONF_DEVICE_CLASS: DEVICE_CLASS_MOISTURE, }, { CONF_NAME: "Demo Movement Backyard", CONF_DEVICE_CLASS: DEVICE_CLASS_MOTION, }, ], ): [ binary_sensor.binary_sensor_schema(DemoBinarySensor).extend( cv.polling_component_schema("60s") ) ], cv.Optional( CONF_CLIMATES, default=[ { CONF_NAME: "Demo Heatpump", CONF_TYPE: 1, }, { CONF_NAME: "Demo HVAC", CONF_TYPE: 2, }, { CONF_NAME: "Demo Ecobee",
import esphome.codegen as cg from esphome.const import CONF_ID from .. import nextion_ns, CONF_NEXTION_ID from ..base_component import ( setup_component_core_, CONFIG_TEXT_COMPONENT_SCHEMA, ) CODEOWNERS = ["@senexcrenshaw"] NextionTextSensor = nextion_ns.class_("NextionTextSensor", text_sensor.TextSensor, cg.PollingComponent) CONFIG_SCHEMA = (text_sensor.text_sensor_schema( klass=NextionTextSensor).extend(CONFIG_TEXT_COMPONENT_SCHEMA).extend( cv.polling_component_schema("never"))) async def to_code(config): hub = await cg.get_variable(config[CONF_NEXTION_ID]) var = cg.new_Pvariable(config[CONF_ID], hub) await text_sensor.register_text_sensor(var, config) await cg.register_component(var, config) cg.add(hub.register_textsensor_component(var)) await setup_component_core_(var, config, ".txt")
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_of_measurement=UNIT_CELSIUS, accuracy_decimals=1, device_class=DEVICE_CLASS_TEMPERATURE, state_class=STATE_CLASS_MEASUREMENT, ).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())) 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) cg.add(var.set_filter(config[CONF_MAINS_FILTER]))
CONFIG_SCHEMA = cv.All( display.FULL_DISPLAY_SCHEMA.extend( { cv.GenerateID(): cv.declare_id(WaveshareEPaper), cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema, cv.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True), cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema, cv.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema, cv.Optional(CONF_FULL_UPDATE_EVERY): cv.uint32_t, cv.Optional(CONF_RESET_DURATION): cv.All( cv.positive_time_period_milliseconds, cv.Range(max=core.TimePeriod(milliseconds=500)), ), } ) .extend(cv.polling_component_schema("1s")) .extend(spi.spi_device_schema()), validate_full_update_every_only_type_a, cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA), ) async def to_code(config): model_type, model = MODELS[config[CONF_MODEL]] if model_type == "a": rhs = WaveshareEPaperTypeA.new(model) var = cg.Pvariable(config[CONF_ID], rhs, WaveshareEPaperTypeA) elif model_type in ("b", "c"): rhs = model.new() var = cg.Pvariable(config[CONF_ID], rhs, model) else:
), 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, ), cv.Optional(CONF_TVOC): sensor.sensor_schema( unit_of_measurement=UNIT_PARTS_PER_BILLION, icon=ICON_RADIATOR, accuracy_decimals=0, state_class=STATE_CLASS_MEASUREMENT, ), } ) .extend(cv.polling_component_schema("5min")) .extend(ble_client.BLE_CLIENT_SCHEMA), ) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await ble_client.register_ble_node(var, config) if CONF_HUMIDITY in config: sens = await sensor.new_sensor(config[CONF_HUMIDITY]) cg.add(var.set_humidity(sens)) if CONF_TEMPERATURE in config: sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
ILI9341_MODEL = cv.enum(MODELS, upper=True, space="_") CONFIG_SCHEMA = cv.All( display.FULL_DISPLAY_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(ili9341), cv.Required(CONF_MODEL): ILI9341_MODEL, cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema, cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema, cv.Optional(CONF_LED_PIN): pins.gpio_output_pin_schema, }).extend(cv.polling_component_schema('1s')).extend(spi.SPI_DEVICE_SCHEMA), cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA)) def to_code(config): if config[CONF_MODEL] == 'M5STACK': lcd_type = ILI9341M5Stack if config[CONF_MODEL] == 'TFT_2.4': lcd_type = ILI9341_24_TFT rhs = lcd_type.new() var = cg.Pvariable(config[CONF_ID], rhs, type=lcd_type) yield cg.register_component(var, config) yield display.register_display(var, config) yield spi.register_spi_device(var, config) cg.add(var.set_model(config[CONF_MODEL]))
MULTI_CONF = True CONF_BEDJET_ID = "bedjet_id" bedjet_ns = cg.esphome_ns.namespace("bedjet") BedJetHub = bedjet_ns.class_("BedJetHub", ble_client.BLEClientNode, cg.PollingComponent) CONFIG_SCHEMA = (cv.COMPONENT_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(BedJetHub), cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock), cv.Optional(CONF_RECEIVE_TIMEOUT, default="0s"): cv.positive_time_period_milliseconds, }).extend(ble_client.BLE_CLIENT_SCHEMA).extend( cv.polling_component_schema("15s"))) BEDJET_CLIENT_SCHEMA = cv.Schema({ cv.Required(CONF_BEDJET_ID): cv.use_id(BedJetHub), }) async def register_bedjet_child(var, config): parent = await cg.get_variable(config[CONF_BEDJET_ID]) cg.add(parent.register_child(var)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config)
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, cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval, }).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)) count = config[CONF_COUNT_MODE] cg.add(var.set_rising_edge_mode(count[CONF_RISING_EDGE])) cg.add(var.set_falling_edge_mode(count[CONF_FALLING_EDGE])) cg.add(var.set_filter_us(config[CONF_INTERNAL_FILTER]))
CONFIG_SCHEMA = cv.All( climate.CLIMATE_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(EQ3Climate), cv.GenerateID(CONF_TIME_ID): cv.use_id(time.RealTimeClock), cv.Required(CONF_MAC_ADDRESS): cv.mac_address, cv.Optional(CONF_VALVE): sensor.sensor_schema(UNIT_PERCENT, ICON_PERCENT, 0), cv.Optional(CONF_PIN): cv.string, cv.Optional(CONF_TEMP): cv.use_id(sensor.Sensor) }).extend(cv.polling_component_schema('4h'))) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield climate.register_climate(var, config) cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex)) time_ = yield cg.get_variable(config[CONF_TIME_ID]) cg.add(var.set_time(time_)) if CONF_TEMP in config: sens = yield cg.get_variable(config[CONF_TEMP]) cg.add(var.set_temperature_sensor(sens))
sensor.sensor_schema(unit_of_measurement=UNIT_VOLT_AMPS_REACTIVE_HOURS, icon=ICON_POWER, accuracy_decimals=2), cv.Optional(CONF_COUNTER_READING_Q_OUT): sensor.sensor_schema(unit_of_measurement=UNIT_VOLT_AMPS_REACTIVE_HOURS, icon=ICON_POWER, accuracy_decimals=2), cv.Optional(CONF_POWER_USAGE_IN): sensor.sensor_schema(unit_of_measurement=UNIT_WATT, icon=ICON_POWER, accuracy_decimals=2), cv.Optional(CONF_POWER_USAGE_OUT): sensor.sensor_schema(unit_of_measurement=UNIT_WATT, icon=ICON_POWER, accuracy_decimals=2), }).extend(cv.polling_component_schema('5s')).extend(cv.COMPONENT_SCHEMA) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) cg.add(var.set_decryption_key(config[CONF_DECRYPTION_KEY])) trigger = yield cg.gpio_pin_expression(config[CONF_TRIGGER_PIN]) cg.add(var.set_trigger_pin(trigger)) rx_pin = yield cg.gpio_pin_expression(config[CONF_RX_PIN]) cg.add(var.set_uart_rx_pin(rx_pin)) tx_pin = yield cg.gpio_pin_expression(config[CONF_TX_PIN])
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import uart from esphome.const import CONF_ID CODEOWNERS = ["@s1lvi0"] DEPENDENCIES = ["uart"] AUTO_LOAD = ["sensor", "text_sensor", "binary_sensor"] CONF_BMS_DALY_ID = "bms_daly_id" daly_bms = cg.esphome_ns.namespace("daly_bms") DalyBmsComponent = daly_bms.class_("DalyBmsComponent", cg.PollingComponent, uart.UARTDevice) CONFIG_SCHEMA = (cv.Schema({ cv.GenerateID(): cv.declare_id(DalyBmsComponent) }).extend(uart.UART_DEVICE_SCHEMA).extend(cv.polling_component_schema("30s"))) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await uart.register_uart_device(var, config)
cv.Optional(CONF_TIMEZONE, default=detect_tz): validate_tz, cv.Optional(CONF_ON_TIME): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CronTrigger), cv.Optional(CONF_SECONDS): validate_cron_seconds, cv.Optional(CONF_MINUTES): validate_cron_minutes, cv.Optional(CONF_HOURS): validate_cron_hours, cv.Optional(CONF_DAYS_OF_MONTH): validate_cron_days_of_month, cv.Optional(CONF_MONTHS): validate_cron_months, cv.Optional(CONF_DAYS_OF_WEEK): validate_cron_days_of_week, cv.Optional(CONF_CRON): validate_cron_raw, cv.Optional(CONF_AT): validate_time_at, }, validate_cron_keys), cv.Optional(CONF_ON_TIME_SYNC): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SyncTrigger), }), }).extend(cv.polling_component_schema('15min')) @coroutine def setup_time_core_(time_var, config): cg.add(time_var.set_timezone(config[CONF_TIMEZONE])) for conf in config.get(CONF_ON_TIME, []): trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], time_var) seconds = conf.get(CONF_SECONDS, list(range(0, 61))) cg.add(trigger.add_seconds(seconds)) minutes = conf.get(CONF_MINUTES, list(range(0, 60))) cg.add(trigger.add_minutes(minutes)) hours = conf.get(CONF_HOURS, list(range(0, 24))) cg.add(trigger.add_hours(hours))
import esphome.codegen as cg import esphome.config_validation as cv from esphome import core, pins from esphome.components import modbus from esphome.const import CONF_ID, CONF_RW_PIN wavinAhc9000_ns = cg.esphome_ns.namespace('wavinAhc9000') WavinAhc9000 = wavinAhc9000_ns.class_('WavinAhc9000', cg.PollingComponent) CONF_WAVINAHC9000_ID = 'wavinAhc9000_id' CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(WavinAhc9000), cv.Required(CONF_RW_PIN): pins.gpio_output_pin_schema }).extend(cv.polling_component_schema('60s')).extend(modbus.modbus_device_schema(0x01)) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield modbus.register_modbus_device(var, config) pin = yield cg.gpio_pin_expression(config[CONF_RW_PIN]) cg.add(var.set_rw_pin(pin))
from esphome.components import sensor, uart from esphome.const import CONF_CURRENT, CONF_ID, CONF_POWER, CONF_VOLTAGE, \ UNIT_VOLT, ICON_FLASH, UNIT_AMPERE, UNIT_WATT DEPENDENCIES = ['uart'] cse7766_ns = cg.esphome_ns.namespace('cse7766') CSE7766Component = cse7766_ns.class_('CSE7766Component', cg.PollingComponent, uart.UARTDevice) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(CSE7766Component), cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1), cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2), cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1), }).extend(cv.polling_component_schema('60s')).extend(uart.UART_DEVICE_SCHEMA) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield uart.register_uart_device(var, config) if CONF_VOLTAGE in config: conf = config[CONF_VOLTAGE] sens = yield sensor.new_sensor(conf) cg.add(var.set_voltage_sensor(sens)) if CONF_CURRENT in config: conf = config[CONF_CURRENT] sens = yield sensor.new_sensor(conf) cg.add(var.set_current_sensor(sens))
'sunrise': ICON_WEATHER_SUNSET_UP, }[config[CONF_TYPE]] return config CONFIG_SCHEMA = cv.All( text_sensor.TEXT_SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_id(SunTextSensor), cv.GenerateID(CONF_SUN_ID): cv.use_id(Sun), cv.Required(CONF_TYPE): cv.one_of(*SUN_TYPES, lower=True), cv.Optional(CONF_ELEVATION, default=DEFAULT_ELEVATION): elevation, cv.Optional(CONF_FORMAT, default='%X'): cv.string_strict, }).extend(cv.polling_component_schema('60s')), validate_optional_icon) def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) yield cg.register_component(var, config) yield text_sensor.register_text_sensor(var, config) paren = yield cg.get_variable(config[CONF_SUN_ID]) cg.add(var.set_parent(paren)) cg.add(var.set_sunrise(SUN_TYPES[config[CONF_TYPE]])) cg.add(var.set_elevation(config[CONF_ELEVATION])) cg.add(var.set_format(config[CONF_FORMAT]))
import esphome.codegen as cg import esphome.config_validation as cv from esphome.components import sensor, spi from esphome.const import CONF_ID, ICON_THERMOMETER, UNIT_CELSIUS max6675_ns = cg.esphome_ns.namespace('max6675') MAX6675Sensor = max6675_ns.class_('MAX6675Sensor', sensor.Sensor, cg.PollingComponent, spi.SPIDevice) CONFIG_SCHEMA = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend( { cv.GenerateID(): cv.declare_id(MAX6675Sensor), }).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)
def dump_schema(): import esphome.config_validation as cv from esphome import automation from esphome.automation import validate_potentially_and_condition from esphome import pins from esphome.core import CORE from esphome.helpers import write_file_if_changed from esphome.components import remote_base # The root directory of the repo root = Path(__file__).parent.parent # Fake some diretory so that get_component works CORE.config_path = str(root) file_path = args.output schema_registry[cv.boolean] = {"type": "boolean"} for v in [ cv.int_, cv.int_range, cv.positive_int, cv.float_, cv.positive_float, cv.positive_float, cv.positive_not_null_int, cv.negative_one_to_one_float, cv.port, ]: schema_registry[v] = {"type": "number"} for v in [ cv.string, cv.string_strict, cv.valid_name, cv.hex_int, cv.hex_int_range, pins.output_pin, pins.input_pin, pins.input_pullup_pin, cv.subscribe_topic, cv.publish_topic, cv.mqtt_payload, cv.ssid, cv.percentage_int, cv.percentage, cv.possibly_negative_percentage, cv.positive_time_period, cv.positive_time_period_microseconds, cv.positive_time_period_milliseconds, cv.positive_time_period_minutes, cv.positive_time_period_seconds, ]: schema_registry[v] = {"type": "string"} schema_registry[validate_potentially_and_condition] = get_ref( "condition_list") for v in [pins.gpio_input_pin_schema, pins.gpio_input_pullup_pin_schema]: schema_registry[v] = get_ref("PIN.GPIO_FULL_INPUT_PIN_SCHEMA") for v in [ pins.gpio_output_pin_schema, pins.internal_gpio_output_pin_schema ]: schema_registry[v] = get_ref("PIN.GPIO_FULL_OUTPUT_PIN_SCHEMA") add_module_schemas("CONFIG", cv) get_jschema("POLLING_COMPONENT", cv.polling_component_schema("60s")) add_pin_schema() add_module_schemas("REMOTE_BASE", remote_base) add_module_schemas("AUTOMATION", automation) load_components() add_registries() definitions["condition_list"] = { JSC_ONEOF: [ { "type": "array", "items": get_ref(JSC_CONDITION) }, get_ref(JSC_CONDITION), ] } output = { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "definitions": definitions, JSC_PROPERTIES: base_props, } add_core() add_buses() add_components() add_registries() # need second pass, e.g. climate.pid.autotune add_pin_registry() solve_pending_refs() write_file_if_changed(file_path, json.dumps(output)) print(f"Wrote {file_path}")
color_channel_schema = sensor.sensor_schema(UNIT_PERCENT, ICON_LIGHTBULB, 1) color_temperature_schema = sensor.sensor_schema(UNIT_KELVIN, ICON_THERMOMETER, 1) illuminance_schema = sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1) CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_id(TCS34725Component), cv.Optional(CONF_RED_CHANNEL): color_channel_schema, 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='2.4ms'): cv.enum(TCS34725_INTEGRATION_TIMES, lower=True), cv.Optional(CONF_GAIN, default='1X'): cv.enum(TCS34725_GAINS, upper=True), }).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x29)) 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_integration_time(config[CONF_INTEGRATION_TIME])) cg.add(var.set_gain(config[CONF_GAIN])) if CONF_RED_CHANNEL in config: sens = yield sensor.new_sensor(config[CONF_RED_CHANNEL]) cg.add(var.set_red_sensor(sens)) if CONF_GREEN_CHANNEL in config: sens = yield sensor.new_sensor(config[CONF_GREEN_CHANNEL])
CODEOWNERS = ["@senexcrenshaw"] NextionBinarySensor = nextion_ns.class_( "NextionBinarySensor", binary_sensor.BinarySensor, cg.PollingComponent ) CONFIG_SCHEMA = cv.All( binary_sensor.BINARY_SENSOR_SCHEMA.extend( { cv.GenerateID(): cv.declare_id(NextionBinarySensor), cv.Optional(CONF_PAGE_ID): cv.uint8_t, cv.Optional(CONF_COMPONENT_ID): cv.uint8_t, } ) .extend(CONFIG_BINARY_SENSOR_SCHEMA) .extend(cv.polling_component_schema("never")), cv.has_at_least_one_key( CONF_PAGE_ID, CONF_COMPONENT_ID, CONF_COMPONENT_NAME, CONF_VARIABLE_NAME, ), ) async def to_code(config): hub = await cg.get_variable(config[CONF_NEXTION_ID]) var = cg.new_Pvariable(config[CONF_ID], hub) await binary_sensor.register_binary_sensor(var, config) await cg.register_component(var, config)
0, DEVICE_CLASS_EMPTY, ), cv.Optional(CONF_PM_2_5): sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER, ICON_GRAIN, 0, DEVICE_CLASS_EMPTY), cv.Optional(CONF_PM_10_0): sensor.sensor_schema(UNIT_MICROGRAMS_PER_CUBIC_METER, ICON_GRAIN, 0, DEVICE_CLASS_EMPTY), cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 0, DEVICE_CLASS_TEMPERATURE), cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 0, DEVICE_CLASS_HUMIDITY), }).extend(cv.polling_component_schema("60s")).extend( uart.UART_DEVICE_SCHEMA)) async def to_code(config): var = cg.new_Pvariable(config[CONF_ID]) await cg.register_component(var, config) await uart.register_uart_device(var, config) if CONF_CO2 in config: sens = await sensor.new_sensor(config[CONF_CO2]) cg.add(var.set_co2_sensor(sens)) if CONF_FORMALDEHYDE in config: sens = await sensor.new_sensor(config[CONF_FORMALDEHYDE]) cg.add(var.set_formaldehyde_sensor(sens)) if CONF_TVOC in config:
ScanResultsWiFiInfo = wifi_info_ns.class_("ScanResultsWiFiInfo", text_sensor.TextSensor, cg.PollingComponent) SSIDWiFiInfo = wifi_info_ns.class_("SSIDWiFiInfo", text_sensor.TextSensor, cg.PollingComponent) BSSIDWiFiInfo = wifi_info_ns.class_("BSSIDWiFiInfo", text_sensor.TextSensor, cg.PollingComponent) MacAddressWifiInfo = wifi_info_ns.class_("MacAddressWifiInfo", text_sensor.TextSensor, cg.Component) CONFIG_SCHEMA = cv.Schema({ cv.Optional(CONF_IP_ADDRESS): text_sensor.text_sensor_schema( klass=IPAddressWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend( cv.polling_component_schema("1s")), cv.Optional(CONF_SCAN_RESULTS): text_sensor.text_sensor_schema( klass=ScanResultsWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend( cv.polling_component_schema("60s")), cv.Optional(CONF_SSID): text_sensor.text_sensor_schema( klass=SSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend( cv.polling_component_schema("1s")), cv.Optional(CONF_BSSID): text_sensor.text_sensor_schema( klass=BSSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend( cv.polling_component_schema("1s")), cv.Optional(CONF_MAC_ADDRESS):