Merge pull request #2545 from esphome/bump-2021.10.0b6

2021.10.0b6

CODEOWNERS

@@ -89,6 +89,7 @@ esphome/components/mcp23x17_base/* @jesserockz
 esphome/components/mcp23xxx_base/* @jesserockz
 esphome/components/mcp2515/* @danielschramm @mvturnho
 esphome/components/mcp9808/* @k7hpn
+esphome/components/md5/* @esphome/core
 esphome/components/mdns/* @esphome/core
 esphome/components/midea/* @dudanov
 esphome/components/mitsubishi/* @RubyBailey

esphome/__main__.py

@@ -180,7 +180,11 @@ def compile_program(args, config):
     from esphome import platformio_api
 
     _LOGGER.info("Compiling app...")
-    return platformio_api.run_compile(config, CORE.verbose)
+    rc = platformio_api.run_compile(config, CORE.verbose)
+    if rc != 0:
+        return rc
+    idedata = platformio_api.get_idedata(config)
+    return 0 if idedata is not None else 1
 
 
 def upload_using_esptool(config, port):
@@ -458,6 +462,21 @@ def command_update_all(args):
     return failed
 
 
+def command_idedata(args, config):
+    from esphome import platformio_api
+    import json
+
+    logging.disable(logging.INFO)
+    logging.disable(logging.WARNING)
+
+    idedata = platformio_api.get_idedata(config)
+    if idedata is None:
+        return 1
+
+    print(json.dumps(idedata.raw, indent=2) + "\n")
+    return 0
+
+
 PRE_CONFIG_ACTIONS = {
     "wizard": command_wizard,
     "version": command_version,
@@ -475,6 +494,7 @@ POST_CONFIG_ACTIONS = {
     "clean-mqtt": command_clean_mqtt,
     "mqtt-fingerprint": command_mqtt_fingerprint,
     "clean": command_clean,
+    "idedata": command_idedata,
 }
 
 
@@ -650,6 +670,11 @@ def parse_args(argv):
         "configuration", help="Your YAML configuration file directories.", nargs="+"
     )
 
+    parser_idedata = subparsers.add_parser("idedata")
+    parser_idedata.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs=1
+    )
+
     # Keep backward compatibility with the old command line format of
     # esphome <config> <command>.
     #
@@ -733,7 +758,12 @@ def run_esphome(argv):
     args = parse_args(argv)
     CORE.dashboard = args.dashboard
 
-    setup_log(args.verbose, args.quiet)
+    setup_log(
+        args.verbose,
+        args.quiet,
+        # Show timestamp for dashboard access logs
+        args.command == "dashboard",
+    )
     if args.deprecated_argv_suggestion is not None and args.command != "vscode":
         _LOGGER.warning(
             "Calling ESPHome with the configuration before the command is deprecated "
@@ -762,7 +792,7 @@ def run_esphome(argv):
 
         config = read_config(dict(args.substitution) if args.substitution else {})
         if config is None:
-            return 1
+            return 2
         CORE.config = config
 
         if args.command not in POST_CONFIG_ACTIONS:

esphome/components/ade7953/ade7953.h

@@ -76,9 +76,9 @@ class ADE7953 : public i2c::I2CDevice, public PollingComponent {
       return err;
     *value = 0;
     *value |= ((uint32_t) recv[0]) << 24;
-    *value |= ((uint32_t) recv[1]) << 24;
-    *value |= ((uint32_t) recv[2]) << 24;
-    *value |= ((uint32_t) recv[3]) << 24;
+    *value |= ((uint32_t) recv[1]) << 16;
+    *value |= ((uint32_t) recv[2]) << 8;
+    *value |= ((uint32_t) recv[3]);
     return i2c::ERROR_OK;
   }
 

esphome/components/ble_client/ble_client.cpp

@@ -11,6 +11,8 @@ namespace ble_client {
 
 static const char *const TAG = "ble_client";
 
+float BLEClient::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
+
 void BLEClient::setup() {
   auto ret = esp_ble_gattc_app_register(this->app_id);
   if (ret) {

esphome/components/ble_client/ble_client.h

@@ -81,6 +81,7 @@ class BLEClient : public espbt::ESPBTClient, public Component {
   void setup() override;
   void dump_config() override;
   void loop() override;
+  float get_setup_priority() const override;
 
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override;

esphome/components/esp32/__init__.py

@@ -7,6 +7,7 @@ from esphome.helpers import write_file_if_changed
 from esphome.const import (
     CONF_BOARD,
     CONF_FRAMEWORK,
+    CONF_SOURCE,
     CONF_TYPE,
     CONF_VARIANT,
     CONF_VERSION,
@@ -26,13 +27,10 @@ from .const import (  # noqa
     KEY_ESP32,
     KEY_SDKCONFIG_OPTIONS,
     KEY_VARIANT,
-    VARIANT_ESP32,
-    VARIANT_ESP32S2,
-    VARIANT_ESP32S3,
     VARIANT_ESP32C3,
-    VARIANT_ESP32H2,
     VARIANTS,
 )
+from .boards import BOARD_TO_VARIANT
 
 # force import gpio to register pin schema
 from .gpio import esp32_pin_to_code  # noqa
@@ -53,7 +51,7 @@ def set_core_data(config):
     elif conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
         CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "arduino"
     CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
-        config[CONF_FRAMEWORK][CONF_VERSION_HINT]
+        config[CONF_FRAMEWORK][CONF_VERSION]
     )
     CORE.data[KEY_ESP32][KEY_BOARD] = config[CONF_BOARD]
     CORE.data[KEY_ESP32][KEY_VARIANT] = config[CONF_VARIANT]
@@ -94,6 +92,13 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
     return f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
 
 
+def _format_framework_espidf_version(ver: cv.Version) -> str:
+    # format the given arduino (https://github.com/espressif/esp-idf/releases) version to
+    # a PIO platformio/framework-espidf value
+    # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-espidf
+    return f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
+
+
 # NOTE: Keep this in mind when updating the recommended version:
 #  * New framework historically have had some regressions, especially for WiFi.
 #    The new version needs to be thoroughly validated before changing the
@@ -123,119 +128,112 @@ ESP_IDF_PLATFORM_VERSION = cv.Version(3, 3, 2)
 def _arduino_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": ("https://github.com/espressif/arduino-esp32.git", cv.Version(2, 0, 0)),
-        "latest": ("", cv.Version(1, 0, 3)),
-        "recommended": (
-            _format_framework_arduino_version(RECOMMENDED_ARDUINO_FRAMEWORK_VERSION),
-            RECOMMENDED_ARDUINO_FRAMEWORK_VERSION,
-        ),
+        "dev": (cv.Version(2, 0, 0), "https://github.com/espressif/arduino-esp32.git"),
+        "latest": (cv.Version(1, 0, 6), None),
+        "recommended": (RECOMMENDED_ARDUINO_FRAMEWORK_VERSION, None),
     }
-    ver_value = value[CONF_VERSION]
-    default_ver_hint = None
-    if ver_value.lower() in lookups:
-        default_ver_hint = str(lookups[ver_value.lower()][1])
-        ver_value = lookups[ver_value.lower()][0]
+
+    if value[CONF_VERSION] in lookups:
+        if CONF_SOURCE in value:
+            raise cv.Invalid(
+                "Framework version needs to be explicitly specified when custom source is used."
+            )
+
+        version, source = lookups[value[CONF_VERSION]]
     else:
-        with cv.suppress_invalid():
-            ver = cv.Version.parse(cv.version_number(value))
-            if ver <= cv.Version(1, 0, 3):
-                ver_value = f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-            else:
-                ver_value = f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-            default_ver_hint = str(ver)
-    value[CONF_VERSION] = ver_value
+        version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
+        source = value.get(CONF_SOURCE, None)
 
-    if CONF_VERSION_HINT not in value and default_ver_hint is None:
-        raise cv.Invalid("Needs a version hint to understand the framework version")
+    value[CONF_VERSION] = str(version)
+    value[CONF_SOURCE] = source or _format_framework_arduino_version(version)
 
-    ver_hint_s = value.get(CONF_VERSION_HINT, default_ver_hint)
-    value[CONF_VERSION_HINT] = ver_hint_s
-    plat_ver = value.get(CONF_PLATFORM_VERSION, ARDUINO_PLATFORM_VERSION)
-    value[CONF_PLATFORM_VERSION] = str(plat_ver)
+    platform_version = value.get(CONF_PLATFORM_VERSION, ARDUINO_PLATFORM_VERSION)
+    value[CONF_PLATFORM_VERSION] = str(platform_version)
 
-    if cv.Version.parse(ver_hint_s) != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
+    if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
         _LOGGER.warning(
-            "The selected arduino framework version is not the recommended one"
-        )
-        _LOGGER.warning(
-            "If there are connectivity or build issues please remove the manual version"
+            "The selected Arduino framework version is not the recommended one. "
+            "If there are connectivity or build issues please remove the manual version."
         )
 
     return value
 
 
-def _format_framework_espidf_version(ver: cv.Version) -> str:
-    # format the given arduino (https://github.com/espressif/esp-idf/releases) version to
-    # a PIO platformio/framework-espidf value
-    # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-espidf
-    return f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-
-
 def _esp_idf_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": ("https://github.com/espressif/esp-idf.git", cv.Version(4, 3, 1)),
-        "latest": ("", cv.Version(4, 3, 0)),
-        "recommended": (
-            _format_framework_espidf_version(RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION),
-            RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION,
-        ),
+        "dev": (cv.Version(4, 3, 1), "https://github.com/espressif/esp-idf.git"),
+        "latest": (cv.Version(4, 3, 0), None),
+        "recommended": (RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION, None),
     }
-    ver_value = value[CONF_VERSION]
-    default_ver_hint = None
-    if ver_value.lower() in lookups:
-        default_ver_hint = str(lookups[ver_value.lower()][1])
-        ver_value = lookups[ver_value.lower()][0]
+
+    if value[CONF_VERSION] in lookups:
+        if CONF_SOURCE in value:
+            raise cv.Invalid(
+                "Framework version needs to be explicitly specified when custom source is used."
+            )
+
+        version, source = lookups[value[CONF_VERSION]]
     else:
-        with cv.suppress_invalid():
-            ver = cv.Version.parse(cv.version_number(value))
-            ver_value = f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-            default_ver_hint = str(ver)
-    value[CONF_VERSION] = ver_value
+        version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
+        source = value.get(CONF_SOURCE, None)
 
-    if CONF_VERSION_HINT not in value and default_ver_hint is None:
-        raise cv.Invalid("Needs a version hint to understand the framework version")
+    if version < cv.Version(4, 0, 0):
+        raise cv.Invalid("Only ESP-IDF 4.0+ is supported.")
 
-    ver_hint_s = value.get(CONF_VERSION_HINT, default_ver_hint)
-    value[CONF_VERSION_HINT] = ver_hint_s
-    if cv.Version.parse(ver_hint_s) < cv.Version(4, 0, 0):
-        raise cv.Invalid("Only ESP-IDF 4.0+ is supported")
-    if cv.Version.parse(ver_hint_s) != RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION:
+    value[CONF_VERSION] = str(version)
+    value[CONF_SOURCE] = source or _format_framework_espidf_version(version)
+
+    platform_version = value.get(CONF_PLATFORM_VERSION, ESP_IDF_PLATFORM_VERSION)
+    value[CONF_PLATFORM_VERSION] = str(platform_version)
+
+    if version != RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION:
         _LOGGER.warning(
-            "The selected esp-idf framework version is not the recommended one"
+            "The selected ESP-IDF framework version is not the recommended one. "
+            "If there are connectivity or build issues please remove the manual version."
         )
-        _LOGGER.warning(
-            "If there are connectivity or build issues please remove the manual version"
-        )
-
-    plat_ver = value.get(CONF_PLATFORM_VERSION, ESP_IDF_PLATFORM_VERSION)
-    value[CONF_PLATFORM_VERSION] = str(plat_ver)
 
     return value
 
 
-CONF_VERSION_HINT = "version_hint"
+def _detect_variant(value):
+    if CONF_VARIANT not in value:
+        board = value[CONF_BOARD]
+        if board not in BOARD_TO_VARIANT:
+            raise cv.Invalid(
+                "This board is unknown, please set the variant manually",
+                path=[CONF_BOARD],
+            )
+
+        value = value.copy()
+        value[CONF_VARIANT] = BOARD_TO_VARIANT[board]
+
+    return value
+
+
 CONF_PLATFORM_VERSION = "platform_version"
+
 ARDUINO_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-            cv.Optional(CONF_VERSION_HINT): cv.version_number,
+            cv.Optional(CONF_SOURCE): cv.string_strict,
             cv.Optional(CONF_PLATFORM_VERSION): cv.string_strict,
         }
     ),
     _arduino_check_versions,
 )
+
 CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
 ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-            cv.Optional(CONF_VERSION_HINT): cv.version_number,
+            cv.Optional(CONF_SOURCE): cv.string_strict,
+            cv.Optional(CONF_PLATFORM_VERSION): cv.string_strict,
             cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
                 cv.string_strict: cv.string_strict
             },
-            cv.Optional(CONF_PLATFORM_VERSION): cv.string_strict,
             cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
                 {
                     cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
@@ -264,12 +262,11 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Required(CONF_BOARD): cv.string_strict,
-            cv.Optional(CONF_VARIANT, default="ESP32"): cv.one_of(
-                *VARIANTS, upper=True
-            ),
+            cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
             cv.Optional(CONF_FRAMEWORK, default={}): FRAMEWORK_SCHEMA,
         }
     ),
+    _detect_variant,
     set_core_data,
 )
 
@@ -293,7 +290,7 @@ async def to_code(config):
         cg.add_build_flag("-Wno-nonnull-compare")
         cg.add_platformio_option(
             "platform_packages",
-            [f"platformio/framework-espidf @ {conf[CONF_VERSION]}"],
+            [f"platformio/framework-espidf @ {conf[CONF_SOURCE]}"],
         )
         add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_SINGLE_APP", False)
         add_idf_sdkconfig_option("CONFIG_PARTITION_TABLE_CUSTOM", True)
@@ -323,7 +320,7 @@ async def to_code(config):
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
         cg.add_platformio_option(
             "platform_packages",
-            [f"platformio/framework-arduinoespressif32 @ {conf[CONF_VERSION]}"],
+            [f"platformio/framework-arduinoespressif32 @ {conf[CONF_SOURCE]}"],
         )
 
         cg.add_platformio_option("board_build.partitions", "partitions.csv")

esphome/components/esp32/boards.py

@@ -1,3 +1,5 @@
+from .const import VARIANT_ESP32, VARIANT_ESP32S2, VARIANT_ESP32C3
+
 ESP32_BASE_PINS = {
     "TX": 1,
     "RX": 3,
@@ -925,3 +927,125 @@ ESP32_BOARD_PINS = {
     },
     "xinabox_cw02": {"LED": 27},
 }
+
+"""
+BOARD_TO_VARIANT generated with:
+
+git clone https://github.com/platformio/platform-espressif32
+for x in platform-espressif32/boards/*.json; do
+  mcu=$(jq -r .build.mcu <"$x");
+  fname=$(basename "$x")
+  board="${fname%.*}"
+  variant=$(echo "$mcu" | tr '[:lower:]' '[:upper:]')
+  echo "    \"$board\": VARIANT_${variant},"
+done | sort
+"""
+
+BOARD_TO_VARIANT = {
+    "alksesp32": VARIANT_ESP32,
+    "az-delivery-devkit-v4": VARIANT_ESP32,
+    "bpi-bit": VARIANT_ESP32,
+    "briki_abc_esp32": VARIANT_ESP32,
+    "briki_mbc-wb_esp32": VARIANT_ESP32,
+    "d-duino-32": VARIANT_ESP32,
+    "esp320": VARIANT_ESP32,
+    "esp32-c3-devkitm-1": VARIANT_ESP32C3,
+    "esp32cam": VARIANT_ESP32,
+    "esp32-devkitlipo": VARIANT_ESP32,
+    "esp32dev": VARIANT_ESP32,
+    "esp32doit-devkit-v1": VARIANT_ESP32,
+    "esp32doit-espduino": VARIANT_ESP32,
+    "esp32-evb": VARIANT_ESP32,
+    "esp32-gateway": VARIANT_ESP32,
+    "esp32-poe-iso": VARIANT_ESP32,
+    "esp32-poe": VARIANT_ESP32,
+    "esp32-pro": VARIANT_ESP32,
+    "esp32-s2-kaluga-1": VARIANT_ESP32S2,
+    "esp32-s2-saola-1": VARIANT_ESP32S2,
+    "esp32thing_plus": VARIANT_ESP32,
+    "esp32thing": VARIANT_ESP32,
+    "esp32vn-iot-uno": VARIANT_ESP32,
+    "espea32": VARIANT_ESP32,
+    "espectro32": VARIANT_ESP32,
+    "espino32": VARIANT_ESP32,
+    "esp-wrover-kit": VARIANT_ESP32,
+    "etboard": VARIANT_ESP32,
+    "featheresp32-s2": VARIANT_ESP32S2,
+    "featheresp32": VARIANT_ESP32,
+    "firebeetle32": VARIANT_ESP32,
+    "fm-devkit": VARIANT_ESP32,
+    "frogboard": VARIANT_ESP32,
+    "healthypi4": VARIANT_ESP32,
+    "heltec_wifi_kit_32_v2": VARIANT_ESP32,
+    "heltec_wifi_kit_32": VARIANT_ESP32,
+    "heltec_wifi_lora_32_V2": VARIANT_ESP32,
+    "heltec_wifi_lora_32": VARIANT_ESP32,
+    "heltec_wireless_stick_lite": VARIANT_ESP32,
+    "heltec_wireless_stick": VARIANT_ESP32,
+    "honeylemon": VARIANT_ESP32,
+    "hornbill32dev": VARIANT_ESP32,
+    "hornbill32minima": VARIANT_ESP32,
+    "imbrios-logsens-v1p1": VARIANT_ESP32,
+    "inex_openkb": VARIANT_ESP32,
+    "intorobot": VARIANT_ESP32,
+    "iotaap_magnolia": VARIANT_ESP32,
+    "iotbusio": VARIANT_ESP32,
+    "iotbusproteus": VARIANT_ESP32,
+    "kits-edu": VARIANT_ESP32,
+    "labplus_mpython": VARIANT_ESP32,
+    "lolin32_lite": VARIANT_ESP32,
+    "lolin32": VARIANT_ESP32,
+    "lolin_d32_pro": VARIANT_ESP32,
+    "lolin_d32": VARIANT_ESP32,
+    "lopy4": VARIANT_ESP32,
+    "lopy": VARIANT_ESP32,
+    "m5stack-atom": VARIANT_ESP32,
+    "m5stack-core2": VARIANT_ESP32,
+    "m5stack-core-esp32": VARIANT_ESP32,
+    "m5stack-coreink": VARIANT_ESP32,
+    "m5stack-fire": VARIANT_ESP32,
+    "m5stack-grey": VARIANT_ESP32,
+    "m5stack-timer-cam": VARIANT_ESP32,
+    "m5stick-c": VARIANT_ESP32,
+    "magicbit": VARIANT_ESP32,
+    "mgbot-iotik32a": VARIANT_ESP32,
+    "mgbot-iotik32b": VARIANT_ESP32,
+    "mhetesp32devkit": VARIANT_ESP32,
+    "mhetesp32minikit": VARIANT_ESP32,
+    "microduino-core-esp32": VARIANT_ESP32,
+    "nano32": VARIANT_ESP32,
+    "nina_w10": VARIANT_ESP32,
+    "node32s": VARIANT_ESP32,
+    "nodemcu-32s": VARIANT_ESP32,
+    "nscreen-32": VARIANT_ESP32,
+    "odroid_esp32": VARIANT_ESP32,
+    "onehorse32dev": VARIANT_ESP32,
+    "oroca_edubot": VARIANT_ESP32,
+    "pico32": VARIANT_ESP32,
+    "piranha_esp32": VARIANT_ESP32,
+    "pocket_32": VARIANT_ESP32,
+    "pycom_gpy": VARIANT_ESP32,
+    "qchip": VARIANT_ESP32,
+    "quantum": VARIANT_ESP32,
+    "sensesiot_weizen": VARIANT_ESP32,
+    "sg-o_airMon": VARIANT_ESP32,
+    "s_odi_ultra": VARIANT_ESP32,
+    "sparkfun_lora_gateway_1-channel": VARIANT_ESP32,
+    "tinypico": VARIANT_ESP32,
+    "ttgo-lora32-v1": VARIANT_ESP32,
+    "ttgo-lora32-v21": VARIANT_ESP32,
+    "ttgo-lora32-v2": VARIANT_ESP32,
+    "ttgo-t1": VARIANT_ESP32,
+    "ttgo-t7-v13-mini32": VARIANT_ESP32,
+    "ttgo-t7-v14-mini32": VARIANT_ESP32,
+    "ttgo-t-beam": VARIANT_ESP32,
+    "ttgo-t-watch": VARIANT_ESP32,
+    "turta_iot_node": VARIANT_ESP32,
+    "vintlabs-devkit-v1": VARIANT_ESP32,
+    "wemosbat": VARIANT_ESP32,
+    "wemos_d1_mini32": VARIANT_ESP32,
+    "wesp32": VARIANT_ESP32,
+    "widora-air": VARIANT_ESP32,
+    "wifiduino32": VARIANT_ESP32,
+    "xinabox_cw02": VARIANT_ESP32,
+}

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -57,7 +57,7 @@ void ESP32BLEBeacon::setup() {
   );
 }
 
-float ESP32BLEBeacon::get_setup_priority() const { return setup_priority::DATA; }
+float ESP32BLEBeacon::get_setup_priority() const { return setup_priority::BLUETOOTH; }
 void ESP32BLEBeacon::ble_core_task(void *params) {
   ble_setup();
 

esphome/components/esp32_ble_server/ble_server.cpp

@@ -154,7 +154,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
   }
 }
 
-float BLEServer::get_setup_priority() const { return setup_priority::BLUETOOTH - 10; }
+float BLEServer::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
 void BLEServer::dump_config() { ESP_LOGCONFIG(TAG, "ESP32 BLE Server:"); }
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -40,6 +40,8 @@ uint64_t ble_addr_to_uint64(const esp_bd_addr_t address) {
   return u;
 }
 
+float ESP32BLETracker::get_setup_priority() const { return setup_priority::BLUETOOTH; }
+
 void ESP32BLETracker::setup() {
   global_esp32_ble_tracker = this;
   this->scan_result_lock_ = xSemaphoreCreateMutex();

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -171,6 +171,7 @@ class ESP32BLETracker : public Component {
   /// Setup the FreeRTOS task and the Bluetooth stack.
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
 
   void loop() override;
 

esphome/components/esp8266/__init__.py

@@ -4,6 +4,7 @@ from esphome.const import (
     CONF_BOARD,
     CONF_BOARD_FLASH_MODE,
     CONF_FRAMEWORK,
+    CONF_SOURCE,
     CONF_VERSION,
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
@@ -31,7 +32,7 @@ def set_core_data(config):
     CORE.data[KEY_CORE][KEY_TARGET_PLATFORM] = "esp8266"
     CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = "arduino"
     CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
-        config[CONF_FRAMEWORK][CONF_VERSION_HINT]
+        config[CONF_FRAMEWORK][CONF_VERSION]
     )
     CORE.data[KEY_ESP8266][KEY_BOARD] = config[CONF_BOARD]
     return config
@@ -70,66 +71,50 @@ ARDUINO_3_PLATFORM_VERSION = cv.Version(3, 0, 2)
 def _arduino_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": ("https://github.com/esp8266/Arduino.git", cv.Version(3, 0, 2)),
-        "latest": ("", cv.Version(3, 0, 2)),
-        "recommended": (
-            _format_framework_arduino_version(RECOMMENDED_ARDUINO_FRAMEWORK_VERSION),
-            RECOMMENDED_ARDUINO_FRAMEWORK_VERSION,
-        ),
+        "dev": (cv.Version(3, 0, 2), "https://github.com/esp8266/Arduino.git"),
+        "latest": (cv.Version(3, 0, 2), None),
+        "recommended": (RECOMMENDED_ARDUINO_FRAMEWORK_VERSION, None),
     }
-    ver_value = value[CONF_VERSION]
-    default_ver_hint = None
-    if ver_value.lower() in lookups:
-        default_ver_hint = str(lookups[ver_value.lower()][1])
-        ver_value = lookups[ver_value.lower()][0]
+
+    if value[CONF_VERSION] in lookups:
+        if CONF_SOURCE in value:
+            raise cv.Invalid(
+                "Framework version needs to be explicitly specified when custom source is used."
+            )
+
+        version, source = lookups[value[CONF_VERSION]]
     else:
-        with cv.suppress_invalid():
-            ver = cv.Version.parse(cv.version_number(value))
-            if ver <= cv.Version(2, 4, 1):
-                ver_value = f"~1.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-            elif ver <= cv.Version(2, 6, 2):
-                ver_value = f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-            else:
-                ver_value = f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-            default_ver_hint = str(ver)
+        version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
+        source = value.get(CONF_SOURCE, None)
 
-    value[CONF_VERSION] = ver_value
+    value[CONF_VERSION] = str(version)
+    value[CONF_SOURCE] = source or _format_framework_arduino_version(version)
 
-    if CONF_VERSION_HINT not in value and default_ver_hint is None:
-        raise cv.Invalid("Needs a version hint to understand the framework version")
-
-    ver_hint_s = value.get(CONF_VERSION_HINT, default_ver_hint)
-    value[CONF_VERSION_HINT] = ver_hint_s
-    plat_ver = value.get(CONF_PLATFORM_VERSION)
-
-    if plat_ver is None:
-        ver_hint = cv.Version.parse(ver_hint_s)
-        if ver_hint >= cv.Version(3, 0, 0):
-            plat_ver = ARDUINO_3_PLATFORM_VERSION
-        elif ver_hint >= cv.Version(2, 5, 0):
-            plat_ver = ARDUINO_2_PLATFORM_VERSION
+    platform_version = value.get(CONF_PLATFORM_VERSION)
+    if platform_version is None:
+        if version >= cv.Version(3, 0, 0):
+            platform_version = ARDUINO_3_PLATFORM_VERSION
+        elif version >= cv.Version(2, 5, 0):
+            platform_version = ARDUINO_2_PLATFORM_VERSION
         else:
-            plat_ver = cv.Version(1, 8, 0)
-    value[CONF_PLATFORM_VERSION] = str(plat_ver)
+            platform_version = cv.Version(1, 8, 0)
+    value[CONF_PLATFORM_VERSION] = str(platform_version)
 
-    if cv.Version.parse(ver_hint_s) != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
+    if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
         _LOGGER.warning(
-            "The selected arduino framework version is not the recommended one"
-        )
-        _LOGGER.warning(
-            "If there are connectivity or build issues please remove the manual version"
+            "The selected Arduino framework version is not the recommended one. "
+            "If there are connectivity or build issues please remove the manual version."
         )
 
     return value
 
 
-CONF_VERSION_HINT = "version_hint"
 CONF_PLATFORM_VERSION = "platform_version"
 ARDUINO_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-            cv.Optional(CONF_VERSION_HINT): cv.version_number,
+            cv.Optional(CONF_SOURCE): cv.string_strict,
             cv.Optional(CONF_PLATFORM_VERSION): cv.string_strict,
         }
     ),
@@ -167,7 +152,7 @@ async def to_code(config):
     cg.add_build_flag("-DUSE_ESP8266_FRAMEWORK_ARDUINO")
     cg.add_platformio_option(
         "platform_packages",
-        [f"platformio/framework-arduinoespressif8266 @ {conf[CONF_VERSION]}"],
+        [f"platformio/framework-arduinoespressif8266 @ {conf[CONF_SOURCE]}"],
     )
     cg.add_platformio_option(
         "platform", f"platformio/espressif8266 @ {conf[CONF_PLATFORM_VERSION]}"

esphome/components/logger/__init__.py

@@ -19,7 +19,8 @@ from esphome.const import (
     CONF_TX_BUFFER_SIZE,
 )
 from esphome.core import CORE, EsphomeError, Lambda, coroutine_with_priority
-from esphome.components.esp32 import get_esp32_variant, VARIANT_ESP32S2, VARIANT_ESP32C3
+from esphome.components.esp32 import get_esp32_variant
+from esphome.components.esp32.const import VARIANT_ESP32S2, VARIANT_ESP32C3
 
 CODEOWNERS = ["@esphome/core"]
 logger_ns = cg.esphome_ns.namespace("logger")

esphome/components/md5/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@esphome/core"]

esphome/components/md5/md5.cpp

@@ -0,0 +1,51 @@
+#include <cstdio>
+#include <cstring>
+#include "md5.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace md5 {
+
+void MD5Digest::init() {
+  memset(this->digest_, 0, 16);
+  MD5Init(&this->ctx_);
+}
+
+void MD5Digest::add(const uint8_t *data, size_t len) { MD5Update(&this->ctx_, data, len); }
+
+void MD5Digest::calculate() { MD5Final(this->digest_, &this->ctx_); }
+
+void MD5Digest::get_bytes(uint8_t *output) { memcpy(output, this->digest_, 16); }
+
+void MD5Digest::get_hex(char *output) {
+  for (size_t i = 0; i < 16; i++) {
+    sprintf(output + i * 2, "%02x", this->digest_[i]);
+  }
+}
+
+bool MD5Digest::equals_bytes(const char *expected) {
+  for (size_t i = 0; i < 16; i++) {
+    if (expected[i] != this->digest_[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MD5Digest::equals_hex(const char *expected) {
+  for (size_t i = 0; i < 16; i++) {
+    auto high = parse_hex(expected[i * 2]);
+    auto low = parse_hex(expected[i * 2 + 1]);
+    if (!high.has_value() || !low.has_value()) {
+      return false;
+    }
+    auto value = (*high << 4) | *low;
+    if (value != this->digest_[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace md5
+}  // namespace esphome

esphome/components/md5/md5.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_ESP_IDF
+#include "esp32/rom/md5_hash.h"
+#define MD5_CTX_TYPE MD5Context
+#endif
+
+#if defined(USE_ARDUINO) && defined(USE_ESP32)
+#include "rom/md5_hash.h"
+#define MD5_CTX_TYPE MD5Context
+#endif
+
+#if defined(USE_ARDUINO) && defined(USE_ESP8266)
+#include <md5.h>
+#define MD5_CTX_TYPE md5_context_t
+#endif
+
+namespace esphome {
+namespace md5 {
+
+class MD5Digest {
+ public:
+  MD5Digest() = default;
+  ~MD5Digest() = default;
+
+  /// Initialize a new MD5 digest computation.
+  void init();
+
+  /// Add bytes of data for the digest.
+  void add(const uint8_t *data, size_t len);
+  void add(const char *data, size_t len) { this->add((const uint8_t *) data, len); }
+
+  /// Compute the digest, based on the provided data.
+  void calculate();
+
+  /// Retrieve the MD5 digest as bytes.
+  /// The output must be able to hold 16 bytes or more.
+  void get_bytes(uint8_t *output);
+
+  /// Retrieve the MD5 digest as hex characters.
+  /// The output must be able to hold 32 bytes or more.
+  void get_hex(char *output);
+
+  /// Compare the digest against a provided byte-encoded digest (16 bytes).
+  bool equals_bytes(const char *expected);
+
+  /// Compare the digest against a provided hex-encoded digest (32 bytes).
+  bool equals_hex(const char *expected);
+
+ protected:
+  MD5_CTX_TYPE ctx_{};
+  uint8_t digest_[16];
+};
+
+}  // namespace md5
+}  // namespace esphome

esphome/components/modbus_controller/__init__.py

@@ -38,7 +38,7 @@ ModbusRegisterType_ns = modbus_controller_ns.namespace("ModbusRegisterType")
 ModbusRegisterType = ModbusRegisterType_ns.enum("ModbusRegisterType")
 MODBUS_REGISTER_TYPE = {
     "coil": ModbusRegisterType.COIL,
-    "discrete_input": ModbusRegisterType.DISCRETE,
+    "discrete_input": ModbusRegisterType.DISCRETE_INPUT,
     "holding": ModbusRegisterType.HOLDING,
     "read": ModbusRegisterType.READ,
 }

esphome/components/nextion/display.py

@@ -8,7 +8,7 @@ from esphome.const import (
     CONF_BRIGHTNESS,
     CONF_TRIGGER_ID,
 )
-
+from esphome.core import CORE
 from . import Nextion, nextion_ns, nextion_ref
 from .base_component import (
     CONF_ON_SLEEP,
@@ -76,6 +76,9 @@ async def to_code(config):
     if CONF_TFT_URL in config:
         cg.add_define("USE_NEXTION_TFT_UPLOAD")
         cg.add(var.set_tft_url(config[CONF_TFT_URL]))
+        if CORE.is_esp32:
+            cg.add_library("WiFiClientSecure", None)
+            cg.add_library("HTTPClient", None)
 
     if CONF_TOUCH_SLEEP_TIMEOUT in config:
         cg.add(var.set_touch_sleep_timeout_internal(config[CONF_TOUCH_SLEEP_TIMEOUT]))

esphome/components/ota/__init__.py

@@ -15,7 +15,7 @@ from esphome.core import CORE, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network"]
-AUTO_LOAD = ["socket"]
+AUTO_LOAD = ["socket", "md5"]
 
 CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_ON_BEGIN = "on_begin"
@@ -35,20 +35,12 @@ OTAEndTrigger = ota_ns.class_("OTAEndTrigger", automation.Trigger.template())
 OTAErrorTrigger = ota_ns.class_("OTAErrorTrigger", automation.Trigger.template())
 
 
-def validate_password_support(value):
-    if CORE.using_arduino:
-        return value
-    if CORE.using_esp_idf:
-        raise cv.Invalid("Password support is not implemented yet for ESP-IDF")
-    raise NotImplementedError
-
-
 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): cv.All(cv.string, validate_password_support),
+        cv.Optional(CONF_PASSWORD): cv.string,
         cv.Optional(
             CONF_REBOOT_TIMEOUT, default="5min"
         ): cv.positive_time_period_milliseconds,

esphome/components/ota/ota_backend_arduino_esp32.h

@@ -9,6 +9,7 @@ namespace esphome {
 namespace ota {
 
 class ArduinoESP32OTABackend : public OTABackend {
+ public:
   OTAResponseTypes begin(size_t image_size) override;
   void set_update_md5(const char *md5) override;
   OTAResponseTypes write(uint8_t *data, size_t len) override;

esphome/components/ota/ota_backend_esp_idf.cpp

@@ -4,6 +4,7 @@
 #include "ota_backend_esp_idf.h"
 #include "ota_component.h"
 #include <esp_ota_ops.h>
+#include "esphome/components/md5/md5.h"
 
 namespace esphome {
 namespace ota {
@@ -24,15 +25,15 @@ OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
     }
     return OTA_RESPONSE_ERROR_UNKNOWN;
   }
+  this->md5_.init();
   return OTA_RESPONSE_OK;
 }
 
-void IDFOTABackend::set_update_md5(const char *md5) {
-  // pass
-}
+void IDFOTABackend::set_update_md5(const char *expected_md5) { memcpy(this->expected_bin_md5_, expected_md5, 32); }
 
 OTAResponseTypes IDFOTABackend::write(uint8_t *data, size_t len) {
   esp_err_t err = esp_ota_write(this->update_handle_, data, len);
+  this->md5_.add(data, len);
   if (err != ESP_OK) {
     if (err == ESP_ERR_OTA_VALIDATE_FAILED) {
       return OTA_RESPONSE_ERROR_MAGIC;
@@ -45,6 +46,11 @@ OTAResponseTypes IDFOTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes IDFOTABackend::end() {
+  this->md5_.calculate();
+  if (!this->md5_.equals_hex(this->expected_bin_md5_)) {
+    this->abort();
+    return OTA_RESPONSE_ERROR_UPDATE_END;
+  }
   esp_err_t err = esp_ota_end(this->update_handle_);
   this->update_handle_ = 0;
   if (err == ESP_OK) {

esphome/components/ota/ota_backend_esp_idf.h

@@ -5,6 +5,7 @@
 #include "ota_component.h"
 #include "ota_backend.h"
 #include <esp_ota_ops.h>
+#include "esphome/components/md5/md5.h"
 
 namespace esphome {
 namespace ota {
@@ -20,6 +21,8 @@ class IDFOTABackend : public OTABackend {
  private:
   esp_ota_handle_t update_handle_{0};
   const esp_partition_t *partition_;
+  md5::MD5Digest md5_{};
+  char expected_bin_md5_[32];
 };
 
 }  // namespace ota

esphome/components/ota/ota_component.cpp

@@ -8,15 +8,12 @@
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/util.h"
+#include "esphome/components/md5/md5.h"
 #include "esphome/components/network/util.h"
 
 #include <cerrno>
 #include <cstdio>
 
-#ifdef USE_OTA_PASSWORD
-#include <MD5Builder.h>
-#endif
-
 namespace esphome {
 namespace ota {
 
@@ -173,12 +170,12 @@ void OTAComponent::handle_() {
   if (!this->password_.empty()) {
     buf[0] = OTA_RESPONSE_REQUEST_AUTH;
     this->writeall_(buf, 1);
-    MD5Builder md5_builder{};
-    md5_builder.begin();
+    md5::MD5Digest md5{};
+    md5.init();
     sprintf(sbuf, "%08X", random_uint32());
-    md5_builder.add(sbuf);
-    md5_builder.calculate();
-    md5_builder.getChars(sbuf);
+    md5.add(sbuf, 8);
+    md5.calculate();
+    md5.get_hex(sbuf);
     ESP_LOGV(TAG, "Auth: Nonce is %s", sbuf);
 
     // Send nonce, 32 bytes hex MD5
@@ -188,10 +185,10 @@ void OTAComponent::handle_() {
     }
 
     // prepare challenge
-    md5_builder.begin();
-    md5_builder.add(this->password_.c_str());
+    md5.init();
+    md5.add(this->password_.c_str(), this->password_.length());
     // add nonce
-    md5_builder.add(sbuf);
+    md5.add(sbuf, 32);
 
     // Receive cnonce, 32 bytes hex MD5
     if (!this->readall_(buf, 32)) {
@@ -201,11 +198,11 @@ void OTAComponent::handle_() {
     sbuf[32] = '\0';
     ESP_LOGV(TAG, "Auth: CNonce is %s", sbuf);
     // add cnonce
-    md5_builder.add(sbuf);
+    md5.add(sbuf, 32);
 
     // calculate result
-    md5_builder.calculate();
-    md5_builder.getChars(sbuf);
+    md5.calculate();
+    md5.get_hex(sbuf);
     ESP_LOGV(TAG, "Auth: Result is %s", sbuf);
 
     // Receive result, 32 bytes hex MD5

esphome/components/scd4x/scd4x.cpp

@@ -1,4 +1,5 @@
 #include "scd4x.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -38,6 +39,7 @@ void SCD4XComponent::setup() {
       return;
     }
 
+    uint32_t stop_measurement_delay = 0;
     // In order to query the device periodic measurement must be ceased
     if (raw_read_status[0]) {
       ESP_LOGD(TAG, "Sensor has data available, stopping periodic measurement");
@@ -46,68 +48,72 @@ void SCD4XComponent::setup() {
         this->mark_failed();
         return;
       }
+      // According to the SCD4x datasheet the sensor will only respond to other commands after waiting 500 ms after
+      // issuing the stop_periodic_measurement command
+      stop_measurement_delay = 500;
     }
+    this->set_timeout(stop_measurement_delay, [this]() {
+      if (!this->write_command_(SCD4X_CMD_GET_SERIAL_NUMBER)) {
+        ESP_LOGE(TAG, "Failed to write get serial command");
+        this->error_code_ = COMMUNICATION_FAILED;
+        this->mark_failed();
+        return;
+      }
 
-    if (!this->write_command_(SCD4X_CMD_GET_SERIAL_NUMBER)) {
-      ESP_LOGE(TAG, "Failed to write get serial command");
-      this->error_code_ = COMMUNICATION_FAILED;
-      this->mark_failed();
-      return;
-    }
+      uint16_t raw_serial_number[3];
+      if (!this->read_data_(raw_serial_number, 3)) {
+        ESP_LOGE(TAG, "Failed to read serial number");
+        this->error_code_ = SERIAL_NUMBER_IDENTIFICATION_FAILED;
+        this->mark_failed();
+        return;
+      }
+      ESP_LOGD(TAG, "Serial number %02d.%02d.%02d", (uint16_t(raw_serial_number[0]) >> 8),
+               uint16_t(raw_serial_number[0] & 0xFF), (uint16_t(raw_serial_number[1]) >> 8));
 
-    uint16_t raw_serial_number[3];
-    if (!this->read_data_(raw_serial_number, 3)) {
-      ESP_LOGE(TAG, "Failed to read serial number");
-      this->error_code_ = SERIAL_NUMBER_IDENTIFICATION_FAILED;
-      this->mark_failed();
-      return;
-    }
-    ESP_LOGD(TAG, "Serial number %02d.%02d.%02d", (uint16_t(raw_serial_number[0]) >> 8),
-             uint16_t(raw_serial_number[0] & 0xFF), (uint16_t(raw_serial_number[1]) >> 8));
-
-    if (!this->write_command_(SCD4X_CMD_TEMPERATURE_OFFSET,
-                              (uint16_t)(temperature_offset_ * SCD4X_TEMPERATURE_OFFSET_MULTIPLIER))) {
-      ESP_LOGE(TAG, "Error setting temperature offset.");
-      this->error_code_ = MEASUREMENT_INIT_FAILED;
-      this->mark_failed();
-      return;
-    }
-
-    // If pressure compensation available use it
-    // else use altitude
-    if (ambient_pressure_compensation_) {
-      if (!this->write_command_(SCD4X_CMD_AMBIENT_PRESSURE_COMPENSATION, ambient_pressure_compensation_)) {
-        ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
+      if (!this->write_command_(SCD4X_CMD_TEMPERATURE_OFFSET,
+                                (uint16_t)(temperature_offset_ * SCD4X_TEMPERATURE_OFFSET_MULTIPLIER))) {
+        ESP_LOGE(TAG, "Error setting temperature offset.");
         this->error_code_ = MEASUREMENT_INIT_FAILED;
         this->mark_failed();
         return;
       }
-    } else {
-      if (!this->write_command_(SCD4X_CMD_ALTITUDE_COMPENSATION, altitude_compensation_)) {
-        ESP_LOGE(TAG, "Error setting altitude compensation.");
+
+      // If pressure compensation available use it
+      // else use altitude
+      if (ambient_pressure_compensation_) {
+        if (!this->update_ambient_pressure_compensation_(ambient_pressure_)) {
+          ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
+          this->error_code_ = MEASUREMENT_INIT_FAILED;
+          this->mark_failed();
+          return;
+        }
+      } else {
+        if (!this->write_command_(SCD4X_CMD_ALTITUDE_COMPENSATION, altitude_compensation_)) {
+          ESP_LOGE(TAG, "Error setting altitude compensation.");
+          this->error_code_ = MEASUREMENT_INIT_FAILED;
+          this->mark_failed();
+          return;
+        }
+      }
+
+      if (!this->write_command_(SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION, enable_asc_ ? 1 : 0)) {
+        ESP_LOGE(TAG, "Error setting automatic self calibration.");
         this->error_code_ = MEASUREMENT_INIT_FAILED;
         this->mark_failed();
         return;
       }
-    }
 
-    if (!this->write_command_(SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION, enable_asc_ ? 1 : 0)) {
-      ESP_LOGE(TAG, "Error setting automatic self calibration.");
-      this->error_code_ = MEASUREMENT_INIT_FAILED;
-      this->mark_failed();
-      return;
-    }
+      // Finally start sensor measurements
+      if (!this->write_command_(SCD4X_CMD_START_CONTINUOUS_MEASUREMENTS)) {
+        ESP_LOGE(TAG, "Error starting continuous measurements.");
+        this->error_code_ = MEASUREMENT_INIT_FAILED;
+        this->mark_failed();
+        return;
+      }
 
-    // Finally start sensor measurements
-    if (!this->write_command_(SCD4X_CMD_START_CONTINUOUS_MEASUREMENTS)) {
-      ESP_LOGE(TAG, "Error starting continuous measurements.");
-      this->error_code_ = MEASUREMENT_INIT_FAILED;
-      this->mark_failed();
-      return;
-    }
-
-    initialized_ = true;
-    ESP_LOGD(TAG, "Sensor initialized");
+      initialized_ = true;
+      ESP_LOGD(TAG, "Sensor initialized");
+    });
   });
 }
 
@@ -150,6 +156,13 @@ void SCD4XComponent::update() {
     return;
   }
 
+  if (this->ambient_pressure_source_ != nullptr) {
+    float pressure = this->ambient_pressure_source_->state / 1000.0f;
+    if (!std::isnan(pressure)) {
+      set_ambient_pressure_compensation(this->ambient_pressure_source_->state / 1000.0f);
+    }
+  }
+
   // Check if data is ready
   if (!this->write_command_(SCD4X_CMD_GET_DATA_READY_STATUS)) {
     this->status_set_warning();
@@ -191,6 +204,28 @@ void SCD4XComponent::update() {
 
   this->status_clear_warning();
 }
+// Note pressure in bar here. Convert to hPa
+void SCD4XComponent::set_ambient_pressure_compensation(float pressure_in_bar) {
+  ambient_pressure_compensation_ = true;
+  uint16_t new_ambient_pressure = (uint16_t)(pressure_in_bar * 1000);
+  // remove millibar from comparison to avoid frequent updates +/- 10 millibar doesn't matter
+  if (initialized_ && (new_ambient_pressure / 10 != ambient_pressure_ / 10)) {
+    update_ambient_pressure_compensation_(new_ambient_pressure);
+    ambient_pressure_ = new_ambient_pressure;
+  } else {
+    ESP_LOGD(TAG, "ambient pressure compensation skipped - no change required");
+  }
+}
+
+bool SCD4XComponent::update_ambient_pressure_compensation_(uint16_t pressure_in_hpa) {
+  if (this->write_command_(SCD4X_CMD_AMBIENT_PRESSURE_COMPENSATION, pressure_in_hpa)) {
+    ESP_LOGD(TAG, "setting ambient pressure compensation to %d hPa", pressure_in_hpa);
+    return true;
+  } else {
+    ESP_LOGE(TAG, "Error setting ambient pressure compensation.");
+    return false;
+  }
+}
 
 uint8_t SCD4XComponent::sht_crc_(uint8_t data1, uint8_t data2) {
   uint8_t bit;

esphome/components/scd4x/scd4x.h

@@ -18,10 +18,8 @@ class SCD4XComponent : public PollingComponent, public i2c::I2CDevice {
 
   void set_automatic_self_calibration(bool asc) { enable_asc_ = asc; }
   void set_altitude_compensation(uint16_t altitude) { altitude_compensation_ = altitude; }
-  void set_ambient_pressure_compensation(float pressure) {
-    ambient_pressure_compensation_ = true;
-    ambient_pressure_ = (uint16_t)(pressure * 1000);
-  }
+  void set_ambient_pressure_compensation(float pressure_in_bar);
+  void set_ambient_pressure_source(sensor::Sensor *pressure) { ambient_pressure_source_ = pressure; }
   void set_temperature_offset(float offset) { temperature_offset_ = offset; };
 
   void set_co2_sensor(sensor::Sensor *co2) { co2_sensor_ = co2; }
@@ -33,6 +31,7 @@ class SCD4XComponent : public PollingComponent, public i2c::I2CDevice {
   bool read_data_(uint16_t *data, uint8_t len);
   bool write_command_(uint16_t command);
   bool write_command_(uint16_t command, uint16_t data);
+  bool update_ambient_pressure_compensation_(uint16_t pressure_in_hpa);
 
   ERRORCODE error_code_;
 
@@ -47,6 +46,8 @@ class SCD4XComponent : public PollingComponent, public i2c::I2CDevice {
   sensor::Sensor *co2_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};
+  // used for compensation
+  sensor::Sensor *ambient_pressure_source_{nullptr};
 };
 
 }  // namespace scd4x

esphome/components/scd4x/sensor.py

@@ -29,6 +29,7 @@ CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
 CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
 CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
 CONF_TEMPERATURE_OFFSET = "temperature_offset"
+CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE = "ambient_pressure_compensation_source"
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -62,6 +63,9 @@ CONFIG_SCHEMA = (
             ),
             cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION): cv.pressure,
             cv.Optional(CONF_TEMPERATURE_OFFSET, default="4°C"): cv.temperature,
+            cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE): cv.use_id(
+                sensor.Sensor
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -92,7 +96,10 @@ async def to_code(config):
             cg.add(getattr(var, funcName)(config[key]))
 
     for key, funcName in SENSOR_MAP.items():
-
         if key in config:
             sens = await sensor.new_sensor(config[key])
             cg.add(getattr(var, funcName)(sens))
+
+    if CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE in config:
+        sens = await cg.get_variable(config[CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE])
+        cg.add(var.set_ambient_pressure_source(sens))

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2021.10.0b3"
+__version__ = "2021.10.0b6"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

esphome/core/config.py

@@ -23,6 +23,7 @@ from esphome.const import (
     CONF_PLATFORMIO_OPTIONS,
     CONF_PRIORITY,
     CONF_PROJECT,
+    CONF_SOURCE,
     CONF_TRIGGER_ID,
     CONF_TYPE,
     CONF_VERSION,
@@ -181,10 +182,12 @@ def preload_core_config(config, result):
         if CONF_BOARD_FLASH_MODE in conf:
             plat_conf[CONF_BOARD_FLASH_MODE] = conf.pop(CONF_BOARD_FLASH_MODE)
         if CONF_ARDUINO_VERSION in conf:
-            plat_conf[CONF_FRAMEWORK] = {
-                CONF_TYPE: "arduino",
-                CONF_VERSION: conf.pop(CONF_ARDUINO_VERSION),
-            }
+            plat_conf[CONF_FRAMEWORK] = {CONF_TYPE: "arduino"}
+            try:
+                cv.Version.parse(conf[CONF_ARDUINO_VERSION])
+                plat_conf[CONF_FRAMEWORK][CONF_VERSION] = conf.pop(CONF_ARDUINO_VERSION)
+            except ValueError:
+                plat_conf[CONF_FRAMEWORK][CONF_SOURCE] = conf.pop(CONF_ARDUINO_VERSION)
         if CONF_BOARD in conf:
             plat_conf[CONF_BOARD] = conf.pop(CONF_BOARD)
         # Insert generated target platform config to main config

esphome/core/defines.h

@@ -26,6 +26,7 @@
 #define USE_LOGGER
 #define USE_MDNS
 #define USE_NUMBER
+#define USE_OTA_PASSWORD
 #define USE_OTA_STATE_CALLBACK
 #define USE_POWER_SUPPLY
 #define USE_PROMETHEUS

esphome/dashboard/dashboard.py

@@ -9,6 +9,7 @@ import json
 import logging
 import multiprocessing
 import os
+from pathlib import Path
 import secrets
 import shutil
 import subprocess
@@ -26,7 +27,7 @@ import tornado.process
 import tornado.web
 import tornado.websocket
 
-from esphome import const, util
+from esphome import const, platformio_api, util
 from esphome.helpers import mkdir_p, get_bool_env, run_system_command
 from esphome.storage_json import (
     EsphomeStorageJSON,
@@ -398,17 +399,45 @@ class DownloadBinaryRequestHandler(BaseHandler):
     @authenticated
     @bind_config
     def get(self, configuration=None):
-        # pylint: disable=no-value-for-parameter
-        storage_path = ext_storage_path(settings.config_dir, configuration)
-        storage_json = StorageJSON.load(storage_path)
-        if storage_json is None:
-            self.send_error()
+        type = self.get_argument("type", "firmware.bin")
+
+        if type == "firmware.bin":
+            storage_path = ext_storage_path(settings.config_dir, configuration)
+            storage_json = StorageJSON.load(storage_path)
+            if storage_json is None:
+                self.send_error(404)
+                return
+            filename = f"{storage_json.name}.bin"
+            path = storage_json.firmware_bin_path
+
+        else:
+            args = ["esphome", "idedata", settings.rel_path(configuration)]
+            rc, stdout, _ = run_system_command(*args)
+
+            if rc != 0:
+                self.send_error(404 if rc == 2 else 500)
+                return
+
+            idedata = platformio_api.IDEData(json.loads(stdout))
+
+            found = False
+            for image in idedata.extra_flash_images:
+                if image.path.endswith(type):
+                    path = image.path
+                    filename = type
+                    found = True
+                    break
+
+            if not found:
+                self.send_error(404)
+                return
+
+        self.set_header("Content-Type", "application/octet-stream")
+        self.set_header("Content-Disposition", f'attachment; filename="{filename}"')
+        if not Path(path).is_file():
+            self.send_error(404)
             return
 
-        path = storage_json.firmware_bin_path
-        self.set_header("Content-Type", "application/octet-stream")
-        filename = f"{storage_json.name}.bin"
-        self.set_header("Content-Disposition", f'attachment; filename="{filename}"')
         with open(path, "rb") as f:
             while True:
                 data = f.read(16384)
@@ -418,6 +447,38 @@ class DownloadBinaryRequestHandler(BaseHandler):
         self.finish()
 
 
+class ManifestRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def get(self, configuration=None):
+        args = ["esphome", "idedata", settings.rel_path(configuration)]
+        rc, stdout, _ = run_system_command(*args)
+
+        if rc != 0:
+            self.send_error(404 if rc == 2 else 500)
+            return
+
+        idedata = platformio_api.IDEData(json.loads(stdout))
+
+        firmware_offset = "0x10000" if idedata.extra_flash_images else "0x0"
+        flash_images = [
+            {
+                "path": f"./download.bin?configuration={configuration}&type=firmware.bin",
+                "offset": firmware_offset,
+            }
+        ] + [
+            {
+                "path": f"./download.bin?configuration={configuration}&type={os.path.basename(image.path)}",
+                "offset": image.offset,
+            }
+            for image in idedata.extra_flash_images
+        ]
+
+        self.set_header("Content-Type", "application/json")
+        self.write(json.dumps(flash_images))
+        self.finish()
+
+
 def _list_dashboard_entries():
     files = settings.list_yaml_files()
     return [DashboardEntry(file) for file in files]
@@ -862,6 +923,7 @@ def make_app(debug=get_bool_env(ENV_DEV)):
             (f"{rel}info", InfoRequestHandler),
             (f"{rel}edit", EditRequestHandler),
             (f"{rel}download.bin", DownloadBinaryRequestHandler),
+            (f"{rel}manifest.json", ManifestRequestHandler),
             (f"{rel}serial-ports", SerialPortRequestHandler),
             (f"{rel}ping", PingRequestHandler),
             (f"{rel}delete", DeleteRequestHandler),

esphome/log.py

@@ -49,8 +49,10 @@ def color(col: str, msg: str, reset: bool = True) -> bool:
 
 
 class ESPHomeLogFormatter(logging.Formatter):
-    def __init__(self):
-        super().__init__(fmt="%(asctime)s %(levelname)s %(message)s", style="%")
+    def __init__(self, *, include_timestamp: bool):
+        fmt = "%(asctime)s " if include_timestamp else ""
+        fmt += "%(levelname)s %(message)s"
+        super().__init__(fmt=fmt, style="%")
 
     def format(self, record):
         formatted = super().format(record)
@@ -64,7 +66,9 @@ class ESPHomeLogFormatter(logging.Formatter):
         return f"{prefix}{formatted}{Style.RESET_ALL}"
 
 
-def setup_log(debug=False, quiet=False):
+def setup_log(
+    debug: bool = False, quiet: bool = False, include_timestamp: bool = False
+) -> None:
     import colorama
 
     if debug:
@@ -79,4 +83,6 @@ def setup_log(debug=False, quiet=False):
     logging.getLogger("urllib3").setLevel(logging.WARNING)
 
     colorama.init()
-    logging.getLogger().handlers[0].setFormatter(ESPHomeLogFormatter())
+    logging.getLogger().handlers[0].setFormatter(
+        ESPHomeLogFormatter(include_timestamp=include_timestamp)
+    )

requirements.txt

@@ -9,7 +9,7 @@ pyserial==3.5
 platformio==5.2.1
 esptool==3.1
 click==8.0.3
-esphome-dashboard==20211011.1
+esphome-dashboard==20211015.0
 aioesphomeapi==9.1.5
 
 # esp-idf requires this, but doesn't bundle it by default