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