def _validate_method(value):
if value is None:
# default method is determined afterwards because it depends on the chip type chosen
return None
compat_methods = {}
for bus in [0, 1]:
for is_async in [False, True]:
compat_methods[f"ESP8266{'_ASYNC' if is_async else ''}_UART{bus}"] = {
CONF_TYPE: METHOD_ESP8266_UART,
CONF_BUS: bus,
CONF_ASYNC: is_async,
}
compat_methods[f"ESP32_I2S_{bus}"] = {
CONF_TYPE: METHOD_ESP32_I2S,
CONF_BUS: bus,
}
for channel in range(8):
compat_methods[f"ESP32_RMT_{channel}"] = {
CONF_TYPE: METHOD_ESP32_RMT,
CONF_CHANNEL: channel,
}
if isinstance(value, str):
if value.upper() in compat_methods:
return _validate_method(compat_methods[value.upper()])
return _validate_method({CONF_TYPE: value})
return cv.typed_schema(
{k: v.method_schema for k, v in METHODS.items()}, lower=True
)(value)
BinarySensorMap = binary_sensor_map_ns.class_('BinarySensorMap', cg.Component, sensor.Sensor)
SensorMapType = binary_sensor_map_ns.enum('SensorMapType')
CONF_GROUP = 'group'
SENSOR_MAP_TYPES = {
CONF_GROUP: SensorMapType.BINARY_SENSOR_MAP_TYPE_GROUP,
}
entry = {
cv.Required(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_VALUE): cv.float_,
}
CONFIG_SCHEMA = cv.typed_schema({
CONF_GROUP: sensor.sensor_schema(UNIT_EMPTY, ICON_CHECK_CIRCLE_OUTLINE, 0).extend({
cv.GenerateID(): cv.declare_id(BinarySensorMap),
cv.Required(CONF_CHANNELS): cv.All(cv.ensure_list(entry), cv.Length(min=1)),
}),
}, lower=True)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
constant = SENSOR_MAP_TYPES[config[CONF_TYPE]]
cg.add(var.set_sensor_type(constant))
for ch in config[CONF_CHANNELS]:
input_var = yield cg.get_variable(ch[CONF_BINARY_SENSOR])
cg.add(var.add_channel(input_var, ch[CONF_VALUE]))
}
else:
conf = {
CONF_TYPE: TYPE_GIT,
CONF_URL: f"https://github.com/{m.group(1)}/{m.group(2)}.git",
}
if m.group(3):
conf[CONF_REF] = m.group(3)
return SOURCE_SCHEMA(conf)
SOURCE_SCHEMA = cv.Any(
validate_source_shorthand,
cv.typed_schema({
TYPE_GIT: cv.Schema(GIT_SCHEMA),
TYPE_LOCAL: cv.Schema(LOCAL_SCHEMA),
}),
)
CONFIG_SCHEMA = cv.ensure_list({
cv.Required(CONF_SOURCE):
SOURCE_SCHEMA,
cv.Optional(CONF_REFRESH, default="1d"):
cv.All(cv.string, cv.source_refresh),
cv.Optional(CONF_COMPONENTS, default="all"):
cv.Any("all", cv.ensure_list(cv.string)),
})
async def to_code(config):
pass
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_BINARY:
cv.Schema({
cv.GenerateID():
cv.declare_id(CustomBinaryOutputConstructor),
cv.Required(CONF_LAMBDA):
cv.returning_lambda,
cv.Required(CONF_OUTPUTS):
cv.ensure_list(
output.BINARY_OUTPUT_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(output.BinaryOutput),
})),
}),
CONF_FLOAT:
cv.Schema({
cv.GenerateID():
cv.declare_id(CustomFloatOutputConstructor),
cv.Required(CONF_LAMBDA):
cv.returning_lambda,
cv.Required(CONF_OUTPUTS):
cv.ensure_list(
output.FLOAT_OUTPUT_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(output.FloatOutput),
})),
}),
},
lower=True,
)
SWITCH_SCHEMA,
}).extend(uart.UART_DEVICE_SCHEMA)
CONFIG_SCHEMA = cv.typed_schema({
CONF_WLAN:
SCHEMA.extend({
cv.GenerateID(): cv.declare_id(PanasonicACWLAN),
}),
CONF_CNT:
SCHEMA.extend({
cv.GenerateID():
cv.declare_id(PanasonicACCNT),
cv.Optional(CONF_ECO_SWITCH):
SWITCH_SCHEMA,
cv.Optional(CONF_ECONAVI_SWITCH):
SWITCH_SCHEMA,
cv.Optional(CONF_MILD_DRY_SWITCH):
SWITCH_SCHEMA,
cv.Optional(CONF_CURRENT_TEMPERATURE_SENSOR):
cv.use_id(sensor.Sensor),
cv.Optional(CONF_CURRENT_POWER_CONSUMPTION):
sensor.sensor_schema(
unit_of_measurement=UNIT_WATT,
accuracy_decimals=0,
device_class=DEVICE_CLASS_POWER,
state_class=STATE_CLASS_MEASUREMENT,
),
}),
})
async def to_code(config):
TemplateFloatOutput = template_ns.class_("TemplateFloatOutput", output.FloatOutput)
CONF_FLOAT = "float"
CONF_WRITE_ACTION = "write_action"
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_BINARY: output.BINARY_OUTPUT_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(TemplateBinaryOutput),
cv.Required(CONF_WRITE_ACTION): automation.validate_automation(
single=True
),
}
),
CONF_FLOAT: output.FLOAT_OUTPUT_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(TemplateFloatOutput),
cv.Required(CONF_WRITE_ACTION): automation.validate_automation(
single=True
),
}
),
},
lower=True,
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
if config[CONF_TYPE] == CONF_BINARY:
cv.Optional(CONF_ADVANCED, default={}):
cv.Schema({
cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False):
cv.boolean,
}),
}),
_esp_idf_check_versions,
)
FRAMEWORK_ESP_IDF = "esp-idf"
FRAMEWORK_ARDUINO = "arduino"
FRAMEWORK_SCHEMA = cv.typed_schema(
{
FRAMEWORK_ESP_IDF: ESP_IDF_FRAMEWORK_SCHEMA,
FRAMEWORK_ARDUINO: ARDUINO_FRAMEWORK_SCHEMA,
},
lower=True,
space="-",
default_type=FRAMEWORK_ARDUINO,
)
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.Required(CONF_BOARD): cv.string_strict,
cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
cv.Optional(CONF_FRAMEWORK, default={}): FRAMEWORK_SCHEMA,
}),
_detect_variant,
set_core_data,
)
weight = match.group(2)
data = {
CONF_TYPE: TYPE_GFONTS,
CONF_FAMILY: family,
}
if weight is not None:
data[CONF_WEIGHT] = weight[1:]
return FILE_SCHEMA(data)
return FILE_SCHEMA({
CONF_TYPE: TYPE_LOCAL,
CONF_PATH: value,
})
TYPED_FILE_SCHEMA = cv.typed_schema({
TYPE_LOCAL: LOCAL_SCHEMA,
TYPE_GFONTS: GFONTS_SCHEMA,
})
def _file_schema(value):
if isinstance(value, str):
return validate_file_shorthand(value)
return TYPED_FILE_SCHEMA(value)
FILE_SCHEMA = cv.Schema(_file_schema)
DEFAULT_GLYPHS = (
' !"%()+=,-.:/0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz°'
)
CONF_RAW_GLYPH_ID = "raw_glyph_id"
SENSOR_MAP_TYPES = {
CONF_GROUP: SensorMapType.BINARY_SENSOR_MAP_TYPE_GROUP,
}
entry = {
cv.Required(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_VALUE): cv.float_,
}
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_GROUP:
sensor.sensor_schema(
BinarySensorMap,
icon=ICON_CHECK_CIRCLE_OUTLINE,
accuracy_decimals=0,
).extend({
cv.Required(CONF_CHANNELS):
cv.All(cv.ensure_list(entry), cv.Length(min=1)),
}),
},
lower=True,
)
async def to_code(config):
var = await sensor.new_sensor(config)
await cg.register_component(var, config)
constant = SENSOR_MAP_TYPES[config[CONF_TYPE]]
cg.add(var.set_sensor_type(constant))
CONFIG_SCHEMA = cv.All(
cv.typed_schema(
{
"internal":
cv.Schema({
cv.GenerateID():
cv.declare_id(I2SAudioMediaPlayer),
cv.Required(CONF_MODE):
cv.enum(INTERNAL_DAC_OPTIONS, lower=True),
}).extend(media_player.MEDIA_PLAYER_SCHEMA).extend(
cv.COMPONENT_SCHEMA),
"external":
cv.Schema({
cv.GenerateID():
cv.declare_id(I2SAudioMediaPlayer),
cv.Required(CONF_I2S_DOUT_PIN):
pins.internal_gpio_output_pin_number,
cv.Required(CONF_I2S_BCLK_PIN):
pins.internal_gpio_output_pin_number,
cv.Required(CONF_I2S_LRCLK_PIN):
pins.internal_gpio_output_pin_number,
cv.Optional(CONF_MUTE_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_MODE, default="mono"):
cv.one_of(*EXTERNAL_DAC_OPTIONS, lower=True),
}).extend(media_player.MEDIA_PLAYER_SCHEMA).extend(
cv.COMPONENT_SCHEMA),
},
key=CONF_DAC_TYPE,
),
cv.only_with_arduino,
SensorItem)
CONFIG_SCHEMA = cv.typed_schema(
{
"coil":
output.BINARY_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend(
{
cv.GenerateID(): cv.declare_id(ModbusBinaryOutput),
cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False):
cv.boolean,
}),
"holding":
output.FLOAT_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend({
cv.GenerateID():
cv.declare_id(ModbusFloatOutput),
cv.Optional(CONF_VALUE_TYPE, default="U_WORD"):
cv.enum(SENSOR_VALUE_TYPE),
cv.Optional(CONF_WRITE_LAMBDA):
cv.returning_lambda,
cv.Optional(CONF_MULTIPLY, default=1.0):
cv.float_,
cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False):
cv.boolean,
}),
},
lower=True,
key=CONF_REGISTER_TYPE,
default_type="holding",
)
}
entry = {
cv.Required(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_VALUE): cv.float_,
}
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_GROUP: sensor.sensor_schema(
icon=ICON_CHECK_CIRCLE_OUTLINE,
accuracy_decimals=0,
state_class=STATE_CLASS_NONE,
).extend(
{
cv.GenerateID(): cv.declare_id(BinarySensorMap),
cv.Required(CONF_CHANNELS): cv.All(
cv.ensure_list(entry), cv.Length(min=1)
),
}
),
},
lower=True,
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await sensor.register_sensor(var, config)
