esphome 2025.7.5__py3-none-any.whl → 2025.8.0b2__py3-none-any.whl

esphome/components/espnow/espnow_component.cpp

@@ -0,0 +1,468 @@
+#include "espnow_component.h"
+
+#ifdef USE_ESP32
+
+#include "espnow_err.h"
+
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+
+#include <esp_event.h>
+#include <esp_mac.h>
+#include <esp_now.h>
+#include <esp_random.h>
+#include <esp_wifi.h>
+#include <cstring>
+#include <memory>
+
+#ifdef USE_WIFI
+#include "esphome/components/wifi/wifi_component.h"
+#endif
+
+namespace esphome::espnow {
+
+static constexpr const char *TAG = "espnow";
+
+static const esp_err_t CONFIG_ESPNOW_WAKE_WINDOW = 50;
+static const esp_err_t CONFIG_ESPNOW_WAKE_INTERVAL = 100;
+
+ESPNowComponent *global_esp_now = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+static const LogString *espnow_error_to_str(esp_err_t error) {
+  switch (error) {
+    case ESP_ERR_ESPNOW_FAILED:
+      return LOG_STR("ESPNow is in fail mode");
+    case ESP_ERR_ESPNOW_OWN_ADDRESS:
+      return LOG_STR("Message to your self");
+    case ESP_ERR_ESPNOW_DATA_SIZE:
+      return LOG_STR("Data size to large");
+    case ESP_ERR_ESPNOW_PEER_NOT_SET:
+      return LOG_STR("Peer address not set");
+    case ESP_ERR_ESPNOW_PEER_NOT_PAIRED:
+      return LOG_STR("Peer address not paired");
+    case ESP_ERR_ESPNOW_NOT_INIT:
+      return LOG_STR("Not init");
+    case ESP_ERR_ESPNOW_ARG:
+      return LOG_STR("Invalid argument");
+    case ESP_ERR_ESPNOW_INTERNAL:
+      return LOG_STR("Internal Error");
+    case ESP_ERR_ESPNOW_NO_MEM:
+      return LOG_STR("Our of memory");
+    case ESP_ERR_ESPNOW_NOT_FOUND:
+      return LOG_STR("Peer not found");
+    case ESP_ERR_ESPNOW_IF:
+      return LOG_STR("Interface does not match");
+    case ESP_OK:
+      return LOG_STR("OK");
+    case ESP_NOW_SEND_FAIL:
+      return LOG_STR("Failed");
+    default:
+      return LOG_STR("Unknown Error");
+  }
+}
+
+std::string peer_str(uint8_t *peer) {
+  if (peer == nullptr || peer[0] == 0) {
+    return "[Not Set]";
+  } else if (memcmp(peer, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
+    return "[Broadcast]";
+  } else if (memcmp(peer, ESPNOW_MULTICAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
+    return "[Multicast]";
+  } else {
+    return format_mac_address_pretty(peer);
+  }
+}
+
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
+void on_send_report(const esp_now_send_info_t *info, esp_now_send_status_t status)
+#else
+void on_send_report(const uint8_t *mac_addr, esp_now_send_status_t status)
+#endif
+{
+  // Allocate an event from the pool
+  ESPNowPacket *packet = global_esp_now->receive_packet_pool_.allocate();
+  if (packet == nullptr) {
+    // No events available - queue is full or we're out of memory
+    global_esp_now->receive_packet_queue_.increment_dropped_count();
+    return;
+  }
+
+// Load new packet data (replaces previous packet)
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
+  packet->load_sent_data(info->des_addr, status);
+#else
+  packet->load_sent_data(mac_addr, status);
+#endif
+
+  // Push the packet to the queue
+  global_esp_now->receive_packet_queue_.push(packet);
+  // Push always because we're the only producer and the pool ensures we never exceed queue size
+}
+
+void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
+  // Allocate an event from the pool
+  ESPNowPacket *packet = global_esp_now->receive_packet_pool_.allocate();
+  if (packet == nullptr) {
+    // No events available - queue is full or we're out of memory
+    global_esp_now->receive_packet_queue_.increment_dropped_count();
+    return;
+  }
+
+  // Load new packet data (replaces previous packet)
+  packet->load_received_data(info, data, size);
+
+  // Push the packet to the queue
+  global_esp_now->receive_packet_queue_.push(packet);
+  // Push always because we're the only producer and the pool ensures we never exceed queue size
+}
+
+ESPNowComponent::ESPNowComponent() { global_esp_now = this; }
+
+void ESPNowComponent::dump_config() {
+  uint32_t version = 0;
+  esp_now_get_version(&version);
+
+  ESP_LOGCONFIG(TAG, "espnow:");
+  if (this->is_disabled()) {
+    ESP_LOGCONFIG(TAG, "  Disabled");
+    return;
+  }
+  ESP_LOGCONFIG(TAG,
+                "  Own address: %s\n"
+                "  Version: v%" PRIu32 "\n"
+                "  Wi-Fi channel: %d",
+                format_mac_address_pretty(this->own_address_).c_str(), version, this->wifi_channel_);
+#ifdef USE_WIFI
+  ESP_LOGCONFIG(TAG, "  Wi-Fi enabled: %s", YESNO(this->is_wifi_enabled()));
+#endif
+}
+
+bool ESPNowComponent::is_wifi_enabled() {
+#ifdef USE_WIFI
+  return wifi::global_wifi_component != nullptr && !wifi::global_wifi_component->is_disabled();
+#else
+  return false;
+#endif
+}
+
+void ESPNowComponent::setup() {
+  if (this->enable_on_boot_) {
+    this->enable_();
+  } else {
+    this->state_ = ESPNOW_STATE_DISABLED;
+  }
+}
+
+void ESPNowComponent::enable() {
+  if (this->state_ == ESPNOW_STATE_ENABLED)
+    return;
+
+  ESP_LOGD(TAG, "Enabling");
+  this->state_ = ESPNOW_STATE_OFF;
+
+  this->enable_();
+}
+
+void ESPNowComponent::enable_() {
+  if (!this->is_wifi_enabled()) {
+    esp_event_loop_create_default();
+
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+
+    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
+    ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
+    ESP_ERROR_CHECK(esp_wifi_start());
+    ESP_ERROR_CHECK(esp_wifi_disconnect());
+
+    this->apply_wifi_channel();
+  }
+  this->get_wifi_channel();
+
+  esp_err_t err = esp_now_init();
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_now_init failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
+
+  err = esp_now_register_recv_cb(on_data_received);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_now_register_recv_cb failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
+
+  err = esp_now_register_send_cb(on_send_report);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_now_register_recv_cb failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
+
+  esp_wifi_get_mac(WIFI_IF_STA, this->own_address_);
+
+#ifdef USE_DEEP_SLEEP
+  esp_now_set_wake_window(CONFIG_ESPNOW_WAKE_WINDOW);
+  esp_wifi_connectionless_module_set_wake_interval(CONFIG_ESPNOW_WAKE_INTERVAL);
+#endif
+
+  this->state_ = ESPNOW_STATE_ENABLED;
+
+  for (auto peer : this->peers_) {
+    this->add_peer(peer.address);
+  }
+}
+
+void ESPNowComponent::disable() {
+  if (this->state_ == ESPNOW_STATE_DISABLED)
+    return;
+
+  ESP_LOGD(TAG, "Disabling");
+  this->state_ = ESPNOW_STATE_DISABLED;
+
+  esp_now_unregister_recv_cb();
+  esp_now_unregister_send_cb();
+
+  esp_err_t err = esp_now_deinit();
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_now_deinit failed! 0x%x", err);
+  }
+}
+
+void ESPNowComponent::apply_wifi_channel() {
+  if (this->state_ == ESPNOW_STATE_DISABLED) {
+    ESP_LOGE(TAG, "Cannot set channel when ESPNOW disabled");
+    this->mark_failed();
+    return;
+  }
+
+  if (this->is_wifi_enabled()) {
+    ESP_LOGE(TAG, "Cannot set channel when Wi-Fi enabled");
+    this->mark_failed();
+    return;
+  }
+
+  ESP_LOGI(TAG, "Channel set to %d.", this->wifi_channel_);
+  esp_wifi_set_promiscuous(true);
+  esp_wifi_set_channel(this->wifi_channel_, WIFI_SECOND_CHAN_NONE);
+  esp_wifi_set_promiscuous(false);
+}
+
+void ESPNowComponent::loop() {
+#ifdef USE_WIFI
+  if (wifi::global_wifi_component != nullptr && wifi::global_wifi_component->is_connected()) {
+    int32_t new_channel = wifi::global_wifi_component->get_wifi_channel();
+    if (new_channel != this->wifi_channel_) {
+      ESP_LOGI(TAG, "Wifi Channel is changed from %d to %d.", this->wifi_channel_, new_channel);
+      this->wifi_channel_ = new_channel;
+    }
+  }
+#endif
+  // Process received packets
+  ESPNowPacket *packet = this->receive_packet_queue_.pop();
+  while (packet != nullptr) {
+    switch (packet->type_) {
+      case ESPNowPacket::RECEIVED: {
+        const ESPNowRecvInfo info = packet->get_receive_info();
+        if (!esp_now_is_peer_exist(info.src_addr)) {
+          bool handled = false;
+          for (auto *handler : this->unknown_peer_handlers_) {
+            if (handler->on_unknown_peer(info, packet->packet_.receive.data, packet->packet_.receive.size)) {
+              handled = true;
+              break;  // If a handler returns true, stop processing further handlers
+            }
+          }
+          if (!handled && this->auto_add_peer_) {
+            this->add_peer(info.src_addr);
+          }
+        }
+        // Intentionally left as if instead of else in case the peer is added above
+        if (esp_now_is_peer_exist(info.src_addr)) {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+          ESP_LOGV(TAG, "<<< [%s -> %s] %s", format_mac_address_pretty(info.src_addr).c_str(),
+                   format_mac_address_pretty(info.des_addr).c_str(),
+                   format_hex_pretty(packet->packet_.receive.data, packet->packet_.receive.size).c_str());
+#endif
+          if (memcmp(info.des_addr, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
+            for (auto *handler : this->broadcasted_handlers_) {
+              if (handler->on_broadcasted(info, packet->packet_.receive.data, packet->packet_.receive.size))
+                break;  // If a handler returns true, stop processing further handlers
+            }
+          } else {
+            for (auto *handler : this->received_handlers_) {
+              if (handler->on_received(info, packet->packet_.receive.data, packet->packet_.receive.size))
+                break;  // If a handler returns true, stop processing further handlers
+            }
+          }
+        }
+        break;
+      }
+      case ESPNowPacket::SENT: {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+        ESP_LOGV(TAG, ">>> [%s] %s", format_mac_address_pretty(packet->packet_.sent.address).c_str(),
+                 LOG_STR_ARG(espnow_error_to_str(packet->packet_.sent.status)));
+#endif
+        if (this->current_send_packet_ != nullptr) {
+          this->current_send_packet_->callback_(packet->packet_.sent.status);
+          this->send_packet_pool_.release(this->current_send_packet_);
+          this->current_send_packet_ = nullptr;  // Reset current packet after sending
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    // Return the packet to the pool
+    this->receive_packet_pool_.release(packet);
+    packet = this->receive_packet_queue_.pop();
+  }
+
+  // Process sending packet queue
+  if (this->current_send_packet_ == nullptr) {
+    this->send_();
+  }
+
+  // Log dropped received packets periodically
+  uint16_t received_dropped = this->receive_packet_queue_.get_and_reset_dropped_count();
+  if (received_dropped > 0) {
+    ESP_LOGW(TAG, "Dropped %u received packets due to buffer overflow", received_dropped);
+  }
+
+  // Log dropped send packets periodically
+  uint16_t send_dropped = this->send_packet_queue_.get_and_reset_dropped_count();
+  if (send_dropped > 0) {
+    ESP_LOGW(TAG, "Dropped %u send packets due to buffer overflow", send_dropped);
+  }
+}
+
+uint8_t ESPNowComponent::get_wifi_channel() {
+  wifi_second_chan_t dummy;
+  esp_wifi_get_channel(&this->wifi_channel_, &dummy);
+  return this->wifi_channel_;
+}
+
+esp_err_t ESPNowComponent::send(const uint8_t *peer_address, const uint8_t *payload, size_t size,
+                                const send_callback_t &callback) {
+  if (this->state_ != ESPNOW_STATE_ENABLED) {
+    return ESP_ERR_ESPNOW_NOT_INIT;
+  } else if (this->is_failed()) {
+    return ESP_ERR_ESPNOW_FAILED;
+  } else if (peer_address == 0ULL) {
+    return ESP_ERR_ESPNOW_PEER_NOT_SET;
+  } else if (memcmp(peer_address, this->own_address_, ESP_NOW_ETH_ALEN) == 0) {
+    return ESP_ERR_ESPNOW_OWN_ADDRESS;
+  } else if (size > ESP_NOW_MAX_DATA_LEN) {
+    return ESP_ERR_ESPNOW_DATA_SIZE;
+  } else if (!esp_now_is_peer_exist(peer_address)) {
+    if (memcmp(peer_address, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0 || this->auto_add_peer_) {
+      esp_err_t err = this->add_peer(peer_address);
+      if (err != ESP_OK) {
+        return err;
+      }
+    } else {
+      return ESP_ERR_ESPNOW_PEER_NOT_PAIRED;
+    }
+  }
+  // Allocate a packet from the pool
+  ESPNowSendPacket *packet = this->send_packet_pool_.allocate();
+  if (packet == nullptr) {
+    this->send_packet_queue_.increment_dropped_count();
+    ESP_LOGE(TAG, "Failed to allocate send packet from pool");
+    this->status_momentary_warning("send-packet-pool-full");
+    return ESP_ERR_ESPNOW_NO_MEM;
+  }
+  // Load the packet data
+  packet->load_data(peer_address, payload, size, callback);
+  // Push the packet to the send queue
+  this->send_packet_queue_.push(packet);
+  return ESP_OK;
+}
+
+void ESPNowComponent::send_() {
+  ESPNowSendPacket *packet = this->send_packet_queue_.pop();
+  if (packet == nullptr) {
+    return;  // No packets to send
+  }
+
+  this->current_send_packet_ = packet;
+  esp_err_t err = esp_now_send(packet->address_, packet->data_, packet->size_);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to send packet to %s - %s", format_mac_address_pretty(packet->address_).c_str(),
+             LOG_STR_ARG(espnow_error_to_str(err)));
+    if (packet->callback_ != nullptr) {
+      packet->callback_(err);
+    }
+    this->status_momentary_warning("send-failed");
+    this->send_packet_pool_.release(packet);
+    this->current_send_packet_ = nullptr;  // Reset current packet
+    return;
+  }
+}
+
+esp_err_t ESPNowComponent::add_peer(const uint8_t *peer) {
+  if (this->state_ != ESPNOW_STATE_ENABLED || this->is_failed()) {
+    return ESP_ERR_ESPNOW_NOT_INIT;
+  }
+
+  if (memcmp(peer, this->own_address_, ESP_NOW_ETH_ALEN) == 0) {
+    this->status_momentary_warning("peer-add-failed");
+    return ESP_ERR_INVALID_MAC;
+  }
+
+  if (!esp_now_is_peer_exist(peer)) {
+    esp_now_peer_info_t peer_info = {};
+    memset(&peer_info, 0, sizeof(esp_now_peer_info_t));
+    peer_info.ifidx = WIFI_IF_STA;
+    memcpy(peer_info.peer_addr, peer, ESP_NOW_ETH_ALEN);
+    esp_err_t err = esp_now_add_peer(&peer_info);
+
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Failed to add peer %s - %s", format_mac_address_pretty(peer).c_str(),
+               LOG_STR_ARG(espnow_error_to_str(err)));
+      this->status_momentary_warning("peer-add-failed");
+      return err;
+    }
+  }
+  bool found = false;
+  for (auto &it : this->peers_) {
+    if (it == peer) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    ESPNowPeer new_peer;
+    memcpy(new_peer.address, peer, ESP_NOW_ETH_ALEN);
+    this->peers_.push_back(new_peer);
+  }
+
+  return ESP_OK;
+}
+
+esp_err_t ESPNowComponent::del_peer(const uint8_t *peer) {
+  if (this->state_ != ESPNOW_STATE_ENABLED || this->is_failed()) {
+    return ESP_ERR_ESPNOW_NOT_INIT;
+  }
+  if (esp_now_is_peer_exist(peer)) {
+    esp_err_t err = esp_now_del_peer(peer);
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Failed to delete peer %s - %s", format_mac_address_pretty(peer).c_str(),
+               LOG_STR_ARG(espnow_error_to_str(err)));
+      this->status_momentary_warning("peer-del-failed");
+      return err;
+    }
+  }
+  for (auto it = this->peers_.begin(); it != this->peers_.end(); ++it) {
+    if (*it == peer) {
+      this->peers_.erase(it);
+      break;
+    }
+  }
+  return ESP_OK;
+}
+
+}  // namespace esphome::espnow
+
+#endif  // USE_ESP32

esphome/components/espnow/espnow_component.h

@@ -0,0 +1,183 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/core/event_pool.h"
+#include "esphome/core/lock_free_queue.h"
+#include "espnow_packet.h"
+
+#include <esp_idf_version.h>
+
+#include <esp_mac.h>
+#include <esp_now.h>
+
+#include <array>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace esphome::espnow {
+
+// Maximum size of the ESPNow event queue - must be power of 2 for lock-free queue
+static constexpr size_t MAX_ESP_NOW_SEND_QUEUE_SIZE = 16;
+static constexpr size_t MAX_ESP_NOW_RECEIVE_QUEUE_SIZE = 16;
+
+using peer_address_t = std::array<uint8_t, ESP_NOW_ETH_ALEN>;
+
+enum class ESPNowTriggers : uint8_t {
+  TRIGGER_NONE = 0,
+  ON_NEW_PEER = 1,
+  ON_RECEIVED = 2,
+  ON_BROADCASTED = 3,
+  ON_SUCCEED = 10,
+  ON_FAILED = 11,
+};
+
+enum ESPNowState : uint8_t {
+  /** Nothing has been initialized yet. */
+  ESPNOW_STATE_OFF = 0,
+  /** ESPNOW is disabled. */
+  ESPNOW_STATE_DISABLED,
+  /** ESPNOW is enabled. */
+  ESPNOW_STATE_ENABLED,
+};
+
+struct ESPNowPeer {
+  uint8_t address[ESP_NOW_ETH_ALEN];  // MAC address of the peer
+
+  bool operator==(const ESPNowPeer &other) const { return memcmp(this->address, other.address, ESP_NOW_ETH_ALEN) == 0; }
+  bool operator==(const uint8_t *other) const { return memcmp(this->address, other, ESP_NOW_ETH_ALEN) == 0; }
+};
+
+/// Handler interface for receiving ESPNow packets from unknown peers
+/// Components should inherit from this class to handle incoming ESPNow data
+class ESPNowUnknownPeerHandler {
+ public:
+  /// Called when an ESPNow packet is received from an unknown peer
+  /// @param info Information about the received packet (sender MAC, etc.)
+  /// @param data Pointer to the received data payload
+  /// @param size Size of the received data in bytes
+  /// @return true if the packet was handled, false otherwise
+  virtual bool on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+};
+
+/// Handler interface for receiving ESPNow packets
+/// Components should inherit from this class to handle incoming ESPNow data
+class ESPNowReceivedPacketHandler {
+ public:
+  /// Called when an ESPNow packet is received
+  /// @param info Information about the received packet (sender MAC, etc.)
+  /// @param data Pointer to the received data payload
+  /// @param size Size of the received data in bytes
+  /// @return true if the packet was handled, false otherwise
+  virtual bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+};
+/// Handler interface for receiving broadcasted ESPNow packets
+/// Components should inherit from this class to handle incoming ESPNow data
+class ESPNowBroadcastedHandler {
+ public:
+  /// Called when a broadcasted ESPNow packet is received
+  /// @param info Information about the received packet (sender MAC, etc.)
+  /// @param data Pointer to the received data payload
+  /// @param size Size of the received data in bytes
+  /// @return true if the packet was handled, false otherwise
+  virtual bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
+};
+
+class ESPNowComponent : public Component {
+ public:
+  ESPNowComponent();
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+
+  float get_setup_priority() const override { return setup_priority::LATE; }
+
+  // Add a peer to the internal list of peers
+  void add_peer(peer_address_t address) {
+    ESPNowPeer peer;
+    memcpy(peer.address, address.data(), ESP_NOW_ETH_ALEN);
+    this->peers_.push_back(peer);
+  }
+  // Add a peer with the esp_now api and add to the internal list if doesnt exist already
+  esp_err_t add_peer(const uint8_t *peer);
+  // Remove a peer with the esp_now api and remove from the internal list if exists
+  esp_err_t del_peer(const uint8_t *peer);
+
+  void set_wifi_channel(uint8_t channel) { this->wifi_channel_ = channel; }
+  void apply_wifi_channel();
+  uint8_t get_wifi_channel();
+
+  void set_auto_add_peer(bool value) { this->auto_add_peer_ = value; }
+
+  void enable();
+  void disable();
+  bool is_disabled() const { return this->state_ == ESPNOW_STATE_DISABLED; };
+  void set_enable_on_boot(bool enable_on_boot) { this->enable_on_boot_ = enable_on_boot; }
+  bool is_wifi_enabled();
+
+  /// @brief Queue a packet to be sent to a specific peer address.
+  /// This method will add the packet to the internal queue and
+  /// call the callback when the packet is sent.
+  /// Only one packet will be sent at any given time and the next one will not be sent until
+  /// the previous one has been acknowledged or failed.
+  /// @param peer_address MAC address of the peer to send the packet to
+  /// @param payload Data payload to send
+  /// @param callback Callback to call when the send operation is complete
+  /// @return ESP_OK on success, or an error code on failure
+  esp_err_t send(const uint8_t *peer_address, const std::vector<uint8_t> &payload,
+                 const send_callback_t &callback = nullptr) {
+    return this->send(peer_address, payload.data(), payload.size(), callback);
+  }
+  esp_err_t send(const uint8_t *peer_address, const uint8_t *payload, size_t size,
+                 const send_callback_t &callback = nullptr);
+
+  void register_received_handler(ESPNowReceivedPacketHandler *handler) { this->received_handlers_.push_back(handler); }
+  void register_unknown_peer_handler(ESPNowUnknownPeerHandler *handler) {
+    this->unknown_peer_handlers_.push_back(handler);
+  }
+  void register_broadcasted_handler(ESPNowBroadcastedHandler *handler) {
+    this->broadcasted_handlers_.push_back(handler);
+  }
+
+ protected:
+  friend void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size);
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
+  friend void on_send_report(const esp_now_send_info_t *info, esp_now_send_status_t status);
+#else
+  friend void on_send_report(const uint8_t *mac_addr, esp_now_send_status_t status);
+#endif
+
+  void enable_();
+  void send_();
+
+  std::vector<ESPNowUnknownPeerHandler *> unknown_peer_handlers_;
+  std::vector<ESPNowReceivedPacketHandler *> received_handlers_;
+  std::vector<ESPNowBroadcastedHandler *> broadcasted_handlers_;
+
+  std::vector<ESPNowPeer> peers_{};
+
+  uint8_t own_address_[ESP_NOW_ETH_ALEN]{0};
+  LockFreeQueue<ESPNowPacket, MAX_ESP_NOW_RECEIVE_QUEUE_SIZE> receive_packet_queue_{};
+  EventPool<ESPNowPacket, MAX_ESP_NOW_RECEIVE_QUEUE_SIZE> receive_packet_pool_{};
+
+  LockFreeQueue<ESPNowSendPacket, MAX_ESP_NOW_SEND_QUEUE_SIZE> send_packet_queue_{};
+  EventPool<ESPNowSendPacket, MAX_ESP_NOW_SEND_QUEUE_SIZE> send_packet_pool_{};
+  ESPNowSendPacket *current_send_packet_{nullptr};  // Currently sending packet, nullptr if none
+
+  uint8_t wifi_channel_{0};
+  ESPNowState state_{ESPNOW_STATE_OFF};
+
+  bool auto_add_peer_{false};
+  bool enable_on_boot_{true};
+};
+
+extern ESPNowComponent *global_esp_now;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace esphome::espnow
+
+#endif  // USE_ESP32

esphome/components/espnow/espnow_err.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <esp_err.h>
+#include <esp_now.h>
+
+namespace esphome::espnow {
+
+static const esp_err_t ESP_ERR_ESPNOW_CMP_BASE = (ESP_ERR_ESPNOW_BASE + 20);
+static const esp_err_t ESP_ERR_ESPNOW_FAILED = (ESP_ERR_ESPNOW_CMP_BASE + 1);
+static const esp_err_t ESP_ERR_ESPNOW_OWN_ADDRESS = (ESP_ERR_ESPNOW_CMP_BASE + 2);
+static const esp_err_t ESP_ERR_ESPNOW_DATA_SIZE = (ESP_ERR_ESPNOW_CMP_BASE + 3);
+static const esp_err_t ESP_ERR_ESPNOW_PEER_NOT_SET = (ESP_ERR_ESPNOW_CMP_BASE + 4);
+static const esp_err_t ESP_ERR_ESPNOW_PEER_NOT_PAIRED = (ESP_ERR_ESPNOW_CMP_BASE + 5);
+
+}  // namespace esphome::espnow
+
+#endif  // USE_ESP32