packet_interface.h

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <utility>
 
#include "esphome/core/string_ref.h"
#include "esphome/core/helpers.h"
#include "esphome/core/component.h"
#include "packet_buffer.h"
 
namespace esphome::packet_interface {
 
constexpr size_t remaining_packet_size(size_t size, size_t used) { return size > used ? size - used : 0; }
 
enum Capability : uint8_t {
  CAPABILITY_ENCRYPTION = 1 << 0,
  CAPABILITY_RELIABILITY = 1 << 1,
  CAPABILITY_SESSION = 1 << 2,
  CAPABILITY_ADDRESSING = 1 << 3,
  CAPABILITY_FRAGMENTATION = 1 << 4,
};
 
class PacketMetaData {
 public:
  StringRef info{};
  uint16_t source_address{0};
  uint16_t destination_address{0};
  float rssi{NAN};
  float snr{NAN};
  uint8_t mac_address[MAC_ADDRESS_SIZE]{};
};
class PacketInterface : public Component {
 public:
  virtual bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) = 0;
 
  size_t get_max_packet_size() const { return this->max_packet_size_; }
  virtual size_t get_send_capacity() const { return SIZE_MAX; }
  uint8_t get_capabilities() const { return this->capabilities_; }
  bool has_capability(Capability capability) const { return (this->capabilities_ & capability) != 0; }
  template<typename F> void add_on_session_state_callback(F &&callback) {
    this->session_callback_.add(std::forward<F>(callback));
  }
 
  PacketInterface *top() {
    PacketInterface *layer = this;
    while (layer->upper_ != nullptr)
      layer = layer->upper_;
    return layer;
  }
  void set_name(const char *name) { this->name_ = name; }
  const char *get_name() const { return this->name_; }
 
  template<typename F> void add_packet_interface_listener(F &&callback) {
    this->callback_.add(std::forward<F>(callback));
  }
 
  void dump_config() override;
 
 protected:
  explicit PacketInterface(size_t max_packet_size) : max_packet_size_(max_packet_size) {}
 
  virtual ~PacketInterface() = default;
  void on_receive_from_interface_(const PacketBuffer &data, const PacketMetaData &meta_data);
  void note_received_(bool understood);
  void stack_on_(PacketInterface *lower, Capability capability) {
    lower->upper_ = this;
    this->inherit_from_(lower, capability);
  }
  void inherit_from_(PacketInterface *lower, Capability capability) {
    this->name_ = lower->name_;
    this->capabilities_ = lower->capabilities_ | capability;
    // A link that has a session of its own, such as TCP, reports it to whatever is stacked above, as does a
    // reliability layer that discards data; the session layer handles the latter itself
    if ((lower->has_capability(CAPABILITY_SESSION) || lower->has_capability(CAPABILITY_RELIABILITY)) &&
        capability != CAPABILITY_SESSION) {
      lower->add_on_session_state_callback([this](bool connected) { this->session_callback_.call(connected); });
    }
  }
 
  LazyCallbackManager<void(const PacketBuffer &, const PacketMetaData &)> callback_;
  LazyCallbackManager<void(bool)> session_callback_;
  PacketInterface *upper_{nullptr};
  const char *name_{""};
  const size_t max_packet_size_;
  uint8_t capabilities_{0};
  uint8_t not_understood_count_{0};
};
}  // namespace esphome::packet_interface