def validate_config(config):
if get_esp32_variant(
) == VARIANT_ESP32C3 and CONF_ESP32_EXT1_WAKEUP in config:
raise cv.Invalid("ESP32-C3 does not support wakeup from touch.")
if get_esp32_variant() == VARIANT_ESP32C3 and CONF_TOUCH_WAKEUP in config:
raise cv.Invalid("ESP32-C3 does not support wakeup from ext1")
return config
def validate_pin_number(value):
valid_pins = WAKEUP_PINS.get(get_esp32_variant(), WAKEUP_PINS[VARIANT_ESP32])
if value[CONF_NUMBER] not in valid_pins:
raise cv.Invalid(
f"Only pins {', '.join(str(x) for x in valid_pins)} support wakeup"
)
return value
def validate_adc_pin(value):
if str(value).upper() == "VCC":
return cv.only_on_esp8266("VCC")
if CORE.is_esp32:
value = pins.internal_gpio_input_pin_number(value)
variant = get_esp32_variant()
if variant not in ESP32_VARIANT_ADC1_PIN_TO_CHANNEL:
raise cv.Invalid(
f"This ESP32 variant ({variant}) is not supported")
if value not in ESP32_VARIANT_ADC1_PIN_TO_CHANNEL[variant]:
raise cv.Invalid(f"{variant} doesn't support ADC on this pin")
return pins.internal_gpio_input_pin_schema(value)
if CORE.is_esp8266:
from esphome.components.esp8266.gpio import CONF_ANALOG
value = pins.internal_gpio_pin_number({
CONF_ANALOG: True,
CONF_INPUT: True
})(value)
if value != 17: # A0
raise cv.Invalid("ESP8266: Only pin A0 (GPIO17) supports ADC.")
return pins.gpio_pin_schema({
CONF_ANALOG: True,
CONF_INPUT: True
},
internal=True)(value)
raise NotImplementedError
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await sensor.register_sensor(var, config)
if config[CONF_PIN] == "VCC":
cg.add_define("USE_ADC_SENSOR_VCC")
else:
pin = await cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
if CONF_RAW in config:
cg.add(var.set_output_raw(config[CONF_RAW]))
if CONF_ATTENUATION in config:
if config[CONF_ATTENUATION] == "auto":
cg.add(var.set_autorange(cg.global_ns.true))
else:
cg.add(var.set_attenuation(config[CONF_ATTENUATION]))
if CORE.is_esp32:
variant = get_esp32_variant()
pin_num = config[CONF_PIN][CONF_NUMBER]
chan = ESP32_VARIANT_ADC1_PIN_TO_CHANNEL[variant][pin_num]
cg.add(var.set_channel(chan))
def _choose_default_method(config):
if CONF_METHOD in config:
return config
config = config.copy()
if CONF_PIN not in config:
config[CONF_METHOD] = _validate_method(METHOD_SPI)
return config
pin = config[CONF_PIN]
if CORE.is_esp8266:
if pin == 3:
config[CONF_METHOD] = _validate_method(METHOD_ESP8266_DMA)
elif pin == 1:
config[CONF_METHOD] = _validate_method({
CONF_TYPE: METHOD_ESP8266_UART,
CONF_BUS: 0,
})
elif pin == 2:
config[CONF_METHOD] = _validate_method({
CONF_TYPE: METHOD_ESP8266_UART,
CONF_BUS: 1,
})
else:
config[CONF_METHOD] = _validate_method(METHOD_BIT_BANG)
if CORE.is_esp32:
if get_esp32_variant() == VARIANT_ESP32C3:
config[CONF_METHOD] = _validate_method(METHOD_ESP32_RMT)
else:
config[CONF_METHOD] = _validate_method(METHOD_ESP32_I2S)
return config
def uart_selection(value):
if CORE.is_esp32:
if get_esp32_variant() in ESP32_REDUCED_VARIANTS:
return cv.one_of(*UART_SELECTION_ESP32_REDUCED, upper=True)(value)
return cv.one_of(*UART_SELECTION_ESP32, upper=True)(value)
if CORE.is_esp8266:
return cv.one_of(*UART_SELECTION_ESP8266, upper=True)(value)
raise NotImplementedError
def uart_selection(value):
if value.upper() in ESP_IDF_UARTS:
if not CORE.using_esp_idf:
raise cv.Invalid(f"Only esp-idf framework supports {value}.")
if CORE.is_esp32:
variant = get_esp32_variant()
if variant in UART_SELECTION_ESP32:
return cv.one_of(*UART_SELECTION_ESP32[variant], upper=True)(value)
if CORE.is_esp8266:
return cv.one_of(*UART_SELECTION_ESP8266, upper=True)(value)
raise NotImplementedError
def _validate_esp32_i2s_bus(value):
if isinstance(value, str) and value.lower() == BUS_DYNAMIC:
value = BUS_DYNAMIC
else:
value = cv.int_(value)
variant_buses = {
VARIANT_ESP32: [0, 1, BUS_DYNAMIC],
VARIANT_ESP32S2: [0, BUS_DYNAMIC],
}
variant = get_esp32_variant()
if variant not in variant_buses:
raise cv.Invalid(f"{variant} does not support the i2s method")
if value not in variant_buses[variant]:
raise cv.Invalid(f"{variant} does not support i2s bus {value}")
return value
def _validate_esp32_rmt_channel(value):
if isinstance(value, str) and value.lower() == CHANNEL_DYNAMIC:
value = CHANNEL_DYNAMIC
else:
value = cv.int_(value)
variant_channels = {
VARIANT_ESP32: [0, 1, 2, 3, 4, 5, 6, 7, CHANNEL_DYNAMIC],
VARIANT_ESP32S2: [0, 1, 2, 3, CHANNEL_DYNAMIC],
VARIANT_ESP32C3: [0, 1, CHANNEL_DYNAMIC],
}
variant = get_esp32_variant()
if variant not in variant_channels:
raise cv.Invalid(f"{variant} does not support the rmt method")
if value not in variant_channels[variant]:
raise cv.Invalid(f"{variant} does not support rmt channel {value}")
return value
def run_esptool(baud_rate):
idedata = platformio_api.get_idedata(config)
firmware_offset = "0x10000" if CORE.is_esp32 else "0x0"
flash_images = [
platformio_api.FlashImage(
path=idedata.firmware_bin_path,
offset=firmware_offset,
),
*idedata.extra_flash_images,
]
mcu = "esp8266"
if CORE.is_esp32:
from esphome.components.esp32 import get_esp32_variant
mcu = get_esp32_variant().lower()
cmd = [
"esptool.py",
"--before",
"default_reset",
"--after",
"hard_reset",
"--baud",
str(baud_rate),
"--port",
port,
"--chip",
mcu,
"write_flash",
"-z",
"--flash_size",
"detect",
]
for img in flash_images:
cmd += [img.offset, img.path]
if os.environ.get("ESPHOME_USE_SUBPROCESS") is None:
import esptool
# pylint: disable=protected-access
return run_external_command(esptool._main, *cmd)
return run_external_process(*cmd)
def from_esphome_core(
esph,
old): # type: (CoreType, Optional[StorageJSON]) -> StorageJSON
hardware = esph.target_platform.upper()
if esph.is_esp32:
from esphome.components import esp32
hardware = esp32.get_esp32_variant(esph)
return StorageJSON(
storage_version=1,
name=esph.name,
comment=esph.comment,
esphome_version=const.__version__,
src_version=1,
address=esph.address,
web_port=esph.web_port,
target_platform=hardware,
build_path=esph.build_path,
firmware_bin_path=esph.firmware_bin,
loaded_integrations=list(esph.loaded_integrations),
)
def _esp32_i2s_default_bus():
return {
VARIANT_ESP32: 1,
VARIANT_ESP32S2: 0,
}.get(get_esp32_variant(), 0)
def _esp32_rmt_default_channel():
return {
VARIANT_ESP32S2: 1,
VARIANT_ESP32C3: 1,
}.get(get_esp32_variant(), 6)
