ESP-IDF support and generic target platforms (#2303)

* Socket refactor and SSL

* esp-idf temp

* Fixes

* Echo component and noise

* Add noise API transport support

* Updates

* ESP-IDF

* Complete

* Fixes

* Fixes

* Versions update

* New i2c APIs

* Complete i2c refactor

* SPI migration

* Revert ESP Preferences migration, too complex for now

* OTA support

* Remove echo again

* Remove ssl again

* GPIOFlags updates

* Rename esphal and ICACHE_RAM_ATTR

* Make ESP32 arduino compilable again

* Fix GPIO flags

* Complete pin registry refactor and fixes

* Fixes to make test1 compile

* Remove sdkconfig file

* Ignore sdkconfig file

* Fixes in reviewing

* Make test2 compile

* Make test4 compile

* Make test5 compile

* Run clang-format

* Fix lint errors

* Use esp-idf APIs instead of btStart

* Another round of fixes

* Start implementing ESP8266

* Make test3 compile

* Guard esp8266 code

* Lint

* Reformat

* Fixes

* Fixes v2

* more fixes

* ESP-IDF tidy target

* Convert ARDUINO_ARCH_ESPxx

* Update WiFiSignalSensor

* Update time ifdefs

* OTA needs millis from hal

* RestartSwitch needs delay from hal

* ESP-IDF Uart

* Fix OTA blank password

* Allow setting sdkconfig

* Fix idf partitions and allow setting sdkconfig from yaml

* Re-add read/write compat APIs and fix esp8266 uart

* Fix esp8266 store log strings in flash

* Fix ESP32 arduino preferences not initialized

* Update ifdefs

* Change how sdkconfig change is detected

* Add checks to ci-custom and fix them

* Run clang-format

* Add esp-idf clang-tidy target and fix errors

* Fixes from clang-tidy idf round 2

* Fixes from compiling tests with esp-idf

* Run clang-format

* Switch test5.yaml to esp-idf

* Implement ESP8266 Preferences

* Lint

* Re-do PIO package version selection a bit

* Fix arduinoespressif32 package version

* Fix unit tests

* Lint

* Lint fixes

* Fix readv/writev not defined

* Fix graphing component

* Re-add all old options from core/config.py

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>

esphome/components/mdns/__init__.py

@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.core import CORE
+
+CODEOWNERS = ["@esphome/core"]
+DEPENDENCIES = ["network"]
+
+CONF_DISABLED = "disabled"
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_DISABLED, default=False): cv.boolean,
+    }
+)
+
+
+async def to_code(config):
+    if config[CONF_DISABLED]:
+        return
+
+    cg.add_define("USE_MDNS")
+    if CORE.using_arduino:
+        if CORE.is_esp32:
+            cg.add_library("ESPmDNS", None)
+        elif CORE.is_esp8266:
+            cg.add_library("ESP8266mDNS", None)

esphome/components/mdns/mdns_component.cpp

@@ -0,0 +1,74 @@
+#include "mdns_component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/version.h"
+#include "esphome/core/application.h"
+
+#ifdef USE_API
+#include "esphome/components/api/api_server.h"
+#endif
+
+namespace esphome {
+namespace mdns {
+
+#ifndef WEBSERVER_PORT
+#define WEBSERVER_PORT 80  // NOLINT
+#endif
+
+std::vector<MDNSService> MDNSComponent::compile_services_() {
+  std::vector<MDNSService> res;
+
+#ifdef USE_API
+  if (api::global_api_server != nullptr) {
+    MDNSService service{};
+    service.service_type = "esphomelib";
+    service.proto = "_tcp";
+    service.port = api::global_api_server->get_port();
+    service.txt_records.push_back({"version", ESPHOME_VERSION});
+    service.txt_records.push_back({"mac", get_mac_address()});
+    const char *platform = nullptr;
+#ifdef USE_ESP8266
+    platform = "ESP8266";
+#endif
+#ifdef USE_ESP32
+    platform = "ESP32";
+#endif
+    if (platform != nullptr) {
+      service.txt_records.push_back({"platform", platform});
+    }
+
+    service.txt_records.push_back({"board", ESPHOME_BOARD});
+
+#ifdef ESPHOME_PROJECT_NAME
+    service.txt_records.push_back({"project_name", ESPHOME_PROJECT_NAME});
+    service.txt_records.push_back({"project_version", ESPHOME_PROJECT_VERSION});
+#endif  // ESPHOME_PROJECT_NAME
+    res.push_back(service);
+  }
+#endif  // USE_API
+
+#ifdef USE_PROMETHEUS
+  {
+    MDNSService service{};
+    service.service_type = "prometheus-http";
+    service.proto = "_tcp";
+    service.port = WEBSERVER_PORT;
+    res.push_back(service);
+  }
+#endif
+
+  if (res.empty()) {
+    // Publish "http" service if not using native API
+    // This is just to have *some* mDNS service so that .local resolution works
+    MDNSService service{};
+    service.service_type = "http";
+    service.proto = "_tcp";
+    service.port = WEBSERVER_PORT;
+    service.txt_records.push_back({"version", ESPHOME_VERSION});
+    res.push_back(service);
+  }
+  return res;
+}
+std::string MDNSComponent::compile_hostname_() { return App.get_name(); }
+
+}  // namespace mdns
+}  // namespace esphome

esphome/components/mdns/mdns_component.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace mdns {
+
+struct MDNSTXTRecord {
+  std::string key;
+  std::string value;
+};
+
+struct MDNSService {
+  std::string service_type;
+  std::string proto;
+  uint16_t port;
+  std::vector<MDNSTXTRecord> txt_records;
+};
+
+class MDNSComponent : public Component {
+ public:
+  void setup() override;
+
+#if defined(USE_ESP8266) && defined(USE_ARDUINO)
+  void loop() override;
+#endif
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
+
+ protected:
+  std::vector<MDNSService> compile_services_();
+  std::string compile_hostname_();
+};
+
+}  // namespace mdns
+}  // namespace esphome

esphome/components/mdns/mdns_esp32_arduino.cpp

@@ -0,0 +1,27 @@
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "mdns_component.h"
+#include "esphome/core/log.h"
+#include <ESPmDNS.h>
+
+namespace esphome {
+namespace mdns {
+
+static const char *const TAG = "mdns";
+
+void MDNSComponent::setup() {
+  MDNS.begin(compile_hostname_().c_str());
+
+  auto services = compile_services_();
+  for (const auto &service : services) {
+    MDNS.addService(service.service_type.c_str(), service.proto.c_str(), service.port);
+    for (const auto &record : service.txt_records) {
+      MDNS.addServiceTxt(service.service_type.c_str(), service.proto.c_str(), record.key.c_str(), record.value.c_str());
+    }
+  }
+}
+
+}  // namespace mdns
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/mdns/mdns_esp8266.cpp

@@ -0,0 +1,32 @@
+#if defined(USE_ESP8266) && defined(USE_ARDUINO)
+
+#include "mdns_component.h"
+#include "esphome/core/log.h"
+#include "esphome/components/network/ip_address.h"
+#include "esphome/components/network/util.h"
+#include <ESP8266mDNS.h>
+
+namespace esphome {
+namespace mdns {
+
+static const char *const TAG = "mdns";
+
+void MDNSComponent::setup() {
+  network::IPAddress addr = network::get_ip_address();
+  MDNS.begin(compile_hostname_().c_str(), (uint32_t) addr);
+
+  auto services = compile_services_();
+  for (const auto &service : services) {
+    MDNS.addService(service.service_type.c_str(), service.proto.c_str(), service.port);
+    for (const auto &record : service.txt_records) {
+      MDNS.addServiceTxt(service.service_type.c_str(), service.proto.c_str(), record.key.c_str(), record.value.c_str());
+    }
+  }
+}
+
+void MDNSComponent::loop() { MDNS.update(); }
+
+}  // namespace mdns
+}  // namespace esphome
+
+#endif

esphome/components/mdns/mdns_esp_idf.cpp

@@ -0,0 +1,52 @@
+#ifdef USE_ESP_IDF
+
+#include "mdns_component.h"
+#include "esphome/core/log.h"
+#include <mdns.h>
+#include <cstring>
+
+namespace esphome {
+namespace mdns {
+
+static const char *const TAG = "mdns";
+
+void MDNSComponent::setup() {
+  esp_err_t err = mdns_init();
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "MDNS init failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
+
+  mdns_hostname_set(compile_hostname_().c_str());
+  mdns_instance_name_set(compile_hostname_().c_str());
+
+  auto services = compile_services_();
+  for (const auto &service : services) {
+    std::vector<mdns_txt_item_t> txt_records;
+    for (const auto &record : service.txt_records) {
+      mdns_txt_item_t it{};
+      // dup strings to ensure the pointer is valid even after the record loop
+      it.key = strdup(record.key.c_str());
+      it.value = strdup(record.value.c_str());
+      txt_records.push_back(it);
+    }
+    err = mdns_service_add(nullptr, service.service_type.c_str(), service.proto.c_str(), service.port,
+                           txt_records.data(), txt_records.size());
+
+    // free records
+    for (const auto &it : txt_records) {
+      delete it.key;    // NOLINT(cppcoreguidelines-owning-memory)
+      delete it.value;  // NOLINT(cppcoreguidelines-owning-memory)
+    }
+
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "Failed to register mDNS service %s: %s", service.service_type.c_str(), esp_err_to_name(err));
+    }
+  }
+}
+
+}  // namespace mdns
+}  // namespace esphome
+
+#endif