import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import CONF_ID, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE
from esphome.core import CORE, coroutine_with_priority
DEPENDENCIES = ['network']
ota_ns = cg.esphome_ns.namespace('ota')
OTAComponent = ota_ns.class_('OTAComponent', cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(OTAComponent),
cv.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
cv.SplitDefault(CONF_PORT, esp8266=8266, esp32=3232): cv.port,
cv.Optional(CONF_PASSWORD, default=''): cv.string,
}).extend(cv.COMPONENT_SCHEMA)
@coroutine_with_priority(50.0)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
cg.add(var.set_port(config[CONF_PORT]))
cg.add(var.set_auth_password(config[CONF_PASSWORD]))
yield cg.register_component(var, config)
if config[CONF_SAFE_MODE]:
cg.add(var.start_safe_mode())
if CORE.is_esp8266:
cg.add_library('Update', None)
if CORE.using_esp_idf:
return cv.declare_id(IDFI2CBus)(value)
raise NotImplementedError
pin_with_input_and_output_support = cv.All(
pins.internal_gpio_pin_number({CONF_INPUT: True}),
pins.internal_gpio_pin_number({CONF_OUTPUT: True}),
)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
_bus_declare_type,
cv.Optional(CONF_SDA, default="SDA"):
pin_with_input_and_output_support,
cv.SplitDefault(CONF_SDA_PULLUP_ENABLED, esp32_idf=True):
cv.All(cv.only_with_esp_idf, cv.boolean),
cv.Optional(CONF_SCL, default="SCL"):
pin_with_input_and_output_support,
cv.SplitDefault(CONF_SCL_PULLUP_ENABLED, esp32_idf=True):
cv.All(cv.only_with_esp_idf, cv.boolean),
cv.Optional(CONF_FREQUENCY, default="50kHz"):
cv.All(cv.frequency, cv.Range(min=0, min_included=False)),
cv.Optional(CONF_SCAN, default=True):
cv.boolean,
}).extend(cv.COMPONENT_SCHEMA)
@coroutine_with_priority(1.0)
async def to_code(config):
cg.add_global(i2c_ns.using)
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(WiFiComponent),
cv.Optional(CONF_NETWORKS): cv.ensure_list(WIFI_NETWORK_STA),
cv.Optional(CONF_SSID): cv.ssid,
cv.Optional(CONF_PASSWORD): validate_password,
cv.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
cv.Optional(CONF_EAP): EAP_AUTH_SCHEMA,
cv.Optional(CONF_AP): WIFI_NETWORK_AP,
cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name,
cv.Optional(
CONF_REBOOT_TIMEOUT, default="15min"
): cv.positive_time_period_milliseconds,
cv.SplitDefault(
CONF_POWER_SAVE_MODE, esp8266="none", esp32="light"
): cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False): cv.boolean,
cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0): cv.All(
cv.decibel, cv.float_range(min=10.0, max=20.5)
),
cv.Optional("enable_mdns"): cv.invalid(
"This option has been removed. Please use the [disabled] option under the "
"new mdns component instead."
),
}
),
_validate,
)
RemoteReceiverComponent = remote_receiver_ns.class_(
'RemoteReceiverComponent', remote_base.RemoteReceiverBase, cg.Component)
MULTI_CONF = True
CONFIG_SCHEMA = remote_base.validate_triggers(
cv.Schema({
cv.GenerateID():
cv.declare_id(RemoteReceiverComponent),
cv.Required(CONF_PIN):
cv.All(pins.internal_gpio_input_pin_schema,
pins.validate_has_interrupt),
cv.Optional(CONF_DUMP, default=[]):
remote_base.validate_dumpers,
cv.Optional(CONF_TOLERANCE, default=25):
cv.All(cv.percentage_int, cv.Range(min=0)),
cv.SplitDefault(CONF_BUFFER_SIZE, esp32='10000b', esp8266='1000b'):
cv.validate_bytes,
cv.Optional(CONF_FILTER, default='50us'):
cv.positive_time_period_microseconds,
cv.Optional(CONF_IDLE, default='10ms'):
cv.positive_time_period_microseconds,
cv.Optional(CONF_MEMORY_BLOCKS, default=3):
cv.Range(min=1, max=8),
}).extend(cv.COMPONENT_SCHEMA))
def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
if CORE.is_esp32:
var = cg.new_Pvariable(config[CONF_ID], pin,
config[CONF_MEMORY_BLOCKS])
RemoteReceiverComponent = remote_receiver_ns.class_(
"RemoteReceiverComponent", remote_base.RemoteReceiverBase, cg.Component)
MULTI_CONF = True
CONFIG_SCHEMA = remote_base.validate_triggers(
cv.Schema({
cv.GenerateID():
cv.declare_id(RemoteReceiverComponent),
cv.Required(CONF_PIN):
cv.All(pins.internal_gpio_input_pin_schema,
pins.validate_has_interrupt),
cv.Optional(CONF_DUMP, default=[]):
remote_base.validate_dumpers,
cv.Optional(CONF_TOLERANCE, default=25):
cv.All(cv.percentage_int, cv.Range(min=0)),
cv.SplitDefault(CONF_BUFFER_SIZE, esp32="10000b", esp8266="1000b"):
cv.validate_bytes,
cv.Optional(CONF_FILTER, default="50us"):
cv.positive_time_period_microseconds,
cv.Optional(CONF_IDLE, default="10ms"):
cv.positive_time_period_microseconds,
cv.Optional(CONF_MEMORY_BLOCKS, default=3):
cv.Range(min=1, max=8),
}).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
pin = await cg.gpio_pin_expression(config[CONF_PIN])
if CORE.is_esp32:
var = cg.new_Pvariable(config[CONF_ID], pin,
config[CONF_MEMORY_BLOCKS])
)
MULTI_CONF = True
CONFIG_SCHEMA = remote_base.validate_triggers(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(RemoteReceiverComponent),
cv.Required(CONF_PIN): cv.All(
pins.internal_gpio_input_pin_schema, pins.validate_has_interrupt
),
cv.Optional(CONF_DUMP, default=[]): remote_base.validate_dumpers,
cv.Optional(CONF_TOLERANCE, default=25): cv.All(
cv.percentage_int, cv.Range(min=0)
),
cv.SplitDefault(
CONF_BUFFER_SIZE, esp32="10000b", esp8266="1000b"
): cv.validate_bytes,
cv.Optional(
CONF_FILTER, default="50us"
): cv.positive_time_period_microseconds,
cv.Optional(
CONF_IDLE, default="10ms"
): cv.positive_time_period_microseconds,
cv.Optional(CONF_MEMORY_BLOCKS, default=3): cv.Range(min=1, max=8),
}
).extend(cv.COMPONENT_SCHEMA)
)
async def to_code(config):
pin = await cg.gpio_pin_expression(config[CONF_PIN])
cv.valid_name,
cv.Required(CONF_PLATFORM):
cv.one_of('ESP8266', 'ESP32', upper=True),
cv.Required(CONF_BOARD):
validate_board,
cv.Optional(CONF_COMMENT):
cv.string,
cv.Optional(CONF_ARDUINO_VERSION, default='recommended'):
validate_arduino_version,
cv.Optional(CONF_BUILD_PATH, default=default_build_path):
cv.string,
cv.Optional(CONF_PLATFORMIO_OPTIONS, default={}):
cv.Schema({
cv.string_strict: cv.Any([cv.string], cv.string),
}),
cv.SplitDefault(CONF_ESP8266_RESTORE_FROM_FLASH, esp8266=False):
cv.All(cv.only_on_esp8266, cv.boolean),
cv.SplitDefault(CONF_BOARD_FLASH_MODE, esp8266='dout'):
cv.one_of(*BUILD_FLASH_MODES, lower=True),
cv.Optional(CONF_ON_BOOT):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(StartupTrigger),
cv.Optional(CONF_PRIORITY, default=600.0):
cv.float_,
}),
cv.Optional(CONF_ON_SHUTDOWN):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(ShutdownTrigger),
}),
import esphome.config_validation as cv
import esphome.codegen as cg
CODEOWNERS = ["@esphome/core"]
CONF_IMPLEMENTATION = "implementation"
IMPLEMENTATION_LWIP_TCP = "lwip_tcp"
IMPLEMENTATION_BSD_SOCKETS = "bsd_sockets"
CONFIG_SCHEMA = cv.Schema({
cv.SplitDefault(
CONF_IMPLEMENTATION,
esp8266=IMPLEMENTATION_LWIP_TCP,
esp32=IMPLEMENTATION_BSD_SOCKETS,
):
cv.one_of(IMPLEMENTATION_LWIP_TCP,
IMPLEMENTATION_BSD_SOCKETS,
lower=True,
space="_"),
})
async def to_code(config):
impl = config[CONF_IMPLEMENTATION]
if impl == IMPLEMENTATION_LWIP_TCP:
cg.add_define("USE_SOCKET_IMPL_LWIP_TCP")
elif impl == IMPLEMENTATION_BSD_SOCKETS:
cg.add_define("USE_SOCKET_IMPL_BSD_SOCKETS")
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID():
cv.declare_id(MQTTClientComponent),
cv.Required(CONF_BROKER):
cv.string_strict,
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.SplitDefault(CONF_IDF_SEND_ASYNC, esp32_idf=False):
cv.All(cv.boolean, cv.only_with_esp_idf),
cv.Optional(CONF_CERTIFICATE_AUTHORITY):
cv.All(cv.string, cv.only_with_esp_idf),
cv.SplitDefault(CONF_SKIP_CERT_CN_CHECK, esp32_idf=False):
cv.All(cv.boolean, cv.only_with_esp_idf),
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.declare_id(WiFiComponent),
cv.Optional(CONF_NETWORKS):
cv.ensure_list(WIFI_NETWORK_STA),
cv.Optional(CONF_SSID):
cv.ssid,
cv.Optional(CONF_PASSWORD):
validate_password,
cv.Optional(CONF_MANUAL_IP):
STA_MANUAL_IP_SCHEMA,
cv.Optional(CONF_AP):
WIFI_NETWORK_AP,
cv.Optional(CONF_DOMAIN, default='.local'):
cv.domain_name,
cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'):
cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266='none', esp32='light'):
cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False):
cv.boolean,
cv.Optional(CONF_USE_ADDRESS):
cv.string_strict,
cv.Optional('hostname'):
cv.invalid("The hostname option has been removed in 1.11.0"),
}), validate)
def safe_ip(ip):
if ip is None:
return IPAddress(0, 0, 0, 0)
return IPAddress(*ip.args)
cv.ensure_list(WIFI_NETWORK_STA),
cv.Optional(CONF_SSID):
cv.ssid,
cv.Optional(CONF_PASSWORD):
validate_password,
cv.Optional(CONF_MANUAL_IP):
STA_MANUAL_IP_SCHEMA,
cv.Optional(CONF_EAP):
EAP_AUTH_SCHEMA,
cv.Optional(CONF_AP):
WIFI_NETWORK_AP,
cv.Optional(CONF_DOMAIN, default='.local'):
cv.domain_name,
cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'):
cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266='none', esp32='light'):
cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False):
cv.boolean,
cv.Optional(CONF_USE_ADDRESS):
cv.string_strict,
cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0):
cv.All(cv.decibel, cv.float_range(min=10.0, max=20.5)),
cv.Optional('hostname'):
cv.invalid("The hostname option has been removed in 1.11.0"),
}), validate)
def eap_auth(config):
if config is None:
return None
"Set 'verify_ssl: false' to make insecure HTTPS requests."
)
return config
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(HttpRequestComponent),
cv.Optional(CONF_USERAGENT, "ESPHome"): cv.string,
cv.Optional(CONF_FOLLOW_REDIRECTS, True): cv.boolean,
cv.Optional(CONF_REDIRECT_LIMIT, 3): cv.int_,
cv.Optional(
CONF_TIMEOUT, default="5s"
): cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_ESP8266_DISABLE_SSL_SUPPORT, esp8266=False): cv.All(
cv.only_on_esp8266, cv.boolean
),
}
).extend(cv.COMPONENT_SCHEMA),
cv.require_framework_version(
esp8266_arduino=cv.Version(2, 5, 1),
esp32_arduino=cv.Version(0, 0, 0),
),
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
cg.add(var.set_timeout(config[CONF_TIMEOUT]))
cg.add(var.set_useragent(config[CONF_USERAGENT]))
def validate_adc_pin(value):
vcc = str(value).upper()
if vcc == 'VCC':
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_FLASH, 2).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:
CONF_DATA_BITS = "data_bits"
CONF_PARITY = "parity"
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID():
cv.declare_id(UARTComponent),
cv.Required(CONF_BAUD_RATE):
cv.int_range(min=1),
cv.Optional(CONF_TX_PIN):
pins.output_pin,
cv.Optional(CONF_RX_PIN):
validate_rx_pin,
cv.Optional(CONF_RX_BUFFER_SIZE, default=256):
cv.validate_bytes,
cv.SplitDefault(CONF_INVERT, esp32=False):
cv.All(cv.only_on_esp32, cv.boolean),
cv.Optional(CONF_STOP_BITS, default=1):
cv.one_of(1, 2, int=True),
cv.Optional(CONF_DATA_BITS, default=8):
cv.int_range(min=5, max=8),
cv.Optional(CONF_PARITY, default="NONE"):
cv.enum(UART_PARITY_OPTIONS, upper=True),
}).extend(cv.COMPONENT_SCHEMA),
cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN),
)
async def to_code(config):
cg.add_global(uart_ns.using)
var = cg.new_Pvariable(config[CONF_ID])
cv.Schema({
cv.GenerateID():
cv.declare_id(Logger),
cv.Optional(CONF_BAUD_RATE, default=115200):
cv.positive_int,
cv.Optional(CONF_TX_BUFFER_SIZE, default=512):
cv.validate_bytes,
cv.Optional(CONF_HARDWARE_UART, default='UART0'):
uart_selection,
cv.Optional(CONF_LEVEL, default='DEBUG'):
is_log_level,
cv.Optional(CONF_LOGS, default={}):
cv.Schema({
cv.string: is_log_level,
}),
cv.SplitDefault(CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH, esp8266=True):
cv.All(cv.only_on_esp8266, cv.boolean),
}).extend(cv.COMPONENT_SCHEMA), validate_local_no_higher_than_global)
@coroutine_with_priority(90.0)
def to_code(config):
baud_rate = config[CONF_BAUD_RATE]
rhs = Logger.new(
baud_rate, config[CONF_TX_BUFFER_SIZE],
HARDWARE_UART_TO_UART_SELECTION[config[CONF_HARDWARE_UART]])
log = cg.Pvariable(config[CONF_ID], rhs)
cg.add(log.pre_setup())
for tag, level in config[CONF_LOGS].items():
cg.add(log.set_log_level(tag, LOG_LEVELS[level]))
raise cv.Invalid("Include has invalid file extension {} - valid extensions are {}"
"".format(ext, ', '.join(VALID_INCLUDE_EXTS)))
return value
CONFIG_SCHEMA = cv.Schema({
cv.Required(CONF_NAME): cv.valid_name,
cv.Required(CONF_PLATFORM): cv.one_of('ESP8266', 'ESP32', upper=True),
cv.Required(CONF_BOARD): validate_board,
cv.Optional(CONF_COMMENT): cv.string,
cv.Optional(CONF_ARDUINO_VERSION, default='recommended'): validate_arduino_version,
cv.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string,
cv.Optional(CONF_PLATFORMIO_OPTIONS, default={}): cv.Schema({
cv.string_strict: cv.Any([cv.string], cv.string),
}),
cv.SplitDefault(CONF_ESP8266_RESTORE_FROM_FLASH, esp8266=False): cv.All(cv.only_on_esp8266,
cv.boolean),
cv.SplitDefault(CONF_BOARD_FLASH_MODE, esp8266='dout'): cv.one_of(*BUILD_FLASH_MODES,
lower=True),
cv.Optional(CONF_ON_BOOT): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StartupTrigger),
cv.Optional(CONF_PRIORITY, default=600.0): cv.float_,
}),
cv.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ShutdownTrigger),
}),
cv.Optional(CONF_ON_LOOP): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoopTrigger),
}),
cv.Optional(CONF_INCLUDES, default=[]): cv.ensure_list(valid_include),
if vcc == "VCC":
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:
CONFIG_SCHEMA = cv.Schema(
{
cv.Required(CONF_NAME): cv.valid_name,
cv.Required(CONF_PLATFORM): cv.one_of("ESP8266", "ESP32", upper=True),
cv.Required(CONF_BOARD): validate_board,
cv.Optional(CONF_COMMENT): cv.string,
cv.Optional(
CONF_ARDUINO_VERSION, default="recommended"
): validate_arduino_version,
cv.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string,
cv.Optional(CONF_PLATFORMIO_OPTIONS, default={}): cv.Schema(
{
cv.string_strict: cv.Any([cv.string], cv.string),
}
),
cv.SplitDefault(CONF_ESP8266_RESTORE_FROM_FLASH, esp8266=False): cv.All(
cv.only_on_esp8266, cv.boolean
),
cv.SplitDefault(CONF_BOARD_FLASH_MODE, esp8266="dout"): cv.one_of(
*BUILD_FLASH_MODES, lower=True
),
cv.Optional(CONF_ON_BOOT): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StartupTrigger),
cv.Optional(CONF_PRIORITY, default=600.0): cv.float_,
}
),
cv.Optional(CONF_ON_SHUTDOWN): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ShutdownTrigger),
}
{
cv.GenerateID():
_choose_pin_declaration,
cv.Required(CONF_NUMBER):
validate_gpio_pin,
cv.Optional(CONF_MODE, default={}):
cv.Schema({
cv.Optional(CONF_INPUT, default=False): cv.boolean,
cv.Optional(CONF_OUTPUT, default=False): cv.boolean,
cv.Optional(CONF_OPEN_DRAIN, default=False): cv.boolean,
cv.Optional(CONF_PULLUP, default=False): cv.boolean,
cv.Optional(CONF_PULLDOWN, default=False): cv.boolean,
}),
cv.Optional(CONF_INVERTED, default=False):
cv.boolean,
cv.SplitDefault(CONF_DRIVE_STRENGTH, esp32_idf="20mA"):
cv.All(
cv.only_with_esp_idf,
cv.float_with_unit("current", "mA", optional_unit=True),
cv.enum(DRIVE_STRENGTHS),
),
},
validate_supports,
)
@pins.PIN_SCHEMA_REGISTRY.register("esp32", ESP32_PIN_SCHEMA)
async def esp32_pin_to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
num = config[CONF_NUMBER]
if CORE.using_esp_idf:
cv.Optional(CONF_DEASSERT_RTS_DTR, default=False): cv.boolean,
cv.Optional(CONF_HARDWARE_UART, default="UART0"): uart_selection,
cv.Optional(CONF_LEVEL, default="DEBUG"): is_log_level,
cv.Optional(CONF_LOGS, default={}): cv.Schema(
{
cv.string: is_log_level,
}
),
cv.Optional(CONF_ON_MESSAGE): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoggerMessageTrigger),
cv.Optional(CONF_LEVEL, default="WARN"): is_log_level,
}
),
cv.SplitDefault(
CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH, esp8266=True
): cv.All(cv.only_on_esp8266, cv.boolean),
}
).extend(cv.COMPONENT_SCHEMA),
validate_local_no_higher_than_global,
)
@coroutine_with_priority(90.0)
async def to_code(config):
baud_rate = config[CONF_BAUD_RATE]
rhs = Logger.new(
baud_rate,
config[CONF_TX_BUFFER_SIZE],
HARDWARE_UART_TO_UART_SELECTION[config[CONF_HARDWARE_UART]],
)
cv.ssid,
cv.Optional(CONF_PASSWORD):
validate_password,
cv.Optional(CONF_MANUAL_IP):
STA_MANUAL_IP_SCHEMA,
cv.Optional(CONF_EAP):
EAP_AUTH_SCHEMA,
cv.Optional(CONF_AP):
WIFI_NETWORK_AP,
cv.Optional(CONF_ENABLE_MDNS, default=True):
cv.boolean,
cv.Optional(CONF_DOMAIN, default=".local"):
cv.domain_name,
cv.Optional(CONF_REBOOT_TIMEOUT, default="15min"):
cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266="none", esp32="light"):
cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False):
cv.boolean,
cv.Optional(CONF_USE_ADDRESS):
cv.string_strict,
cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0):
cv.All(cv.decibel, cv.float_range(min=10.0, max=20.5)),
cv.Optional("hostname"):
cv.invalid("The hostname option has been removed in 1.11.0"),
}),
validate,
)
def eap_auth(config):
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components.esp32 import add_idf_sdkconfig_option
from esphome.const import (
CONF_ENABLE_IPV6, )
CODEOWNERS = ["@esphome/core"]
AUTO_LOAD = ["mdns"]
network_ns = cg.esphome_ns.namespace("network")
IPAddress = network_ns.class_("IPAddress")
CONFIG_SCHEMA = cv.Schema({
cv.SplitDefault(CONF_ENABLE_IPV6, esp32_idf=False):
cv.All(cv.only_with_esp_idf, cv.boolean),
})
async def to_code(config):
if CONF_ENABLE_IPV6 in config and config[CONF_ENABLE_IPV6]:
add_idf_sdkconfig_option("CONFIG_LWIP_IPV6", True)
add_idf_sdkconfig_option("CONFIG_LWIP_IPV6_AUTOCONFIG", True)
