hdlc_reliability.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
#ifdef USE_PACKET_INTERFACE_HDLC
#include <array>
 
#include "packet_interface.h"
 
namespace esphome::packet_interface {
 
class HdlcReliability : public PacketInterface {
 public:
  static constexpr uint8_t MAX_WINDOW = 7;
  static constexpr size_t FRAME_OVERHEAD = 3;
 
  explicit HdlcReliability(PacketInterface *lower);
 
  void setup() override;
  void loop() override;
  void dump_config() override;
  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
  size_t get_send_capacity() const override {
    return this->tx_slots_ == nullptr ? 0 : this->max_queue_length_ - this->outstanding_();
  }
 
  void set_ack_timeout(uint32_t timeout_ms) { this->timeout_ms_ = timeout_ms; }
  void set_ack_delay(uint32_t ack_delay_ms) { this->ack_delay_ms_ = ack_delay_ms; }
  void set_max_queue_length(uint8_t length) { this->max_queue_length_ = length; }
  void set_max_retries(uint8_t retries) { this->max_retries_ = retries; }
 
  bool is_connected() const { return this->state_ == LinkState::LINK_STATE_CONNECTED; }
 
 protected:
  enum class LinkState : uint8_t {
    LINK_STATE_RESET_PENDING,  // SABM to be sent from loop()
    LINK_STATE_RESETTING,      // SABM sent, waiting for UA
    LINK_STATE_CONNECTED,
  };
 
  void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
  void receive_info_(uint8_t control, const uint8_t *payload, size_t length, const PacketMetaData &meta_data);
  bool send_frame_(uint8_t control, const uint8_t *payload, size_t length);
  bool send_supervisory_(uint8_t type);
  bool send_pending_();
  void resend_outstanding_();
  void retry_send_();
  void owe_ack_(bool now);
  void ack_sent_();
  void process_ack_(uint8_t nr);
  void on_timeout_();
  void start_reset_();
  void link_up_();
  void start_timer_();
  void request_loop_();
  uint8_t outstanding_() const { return (this->vs_ - this->va_) & 7; }
  uint8_t slot_index_(uint8_t seq) const { return (this->head_ + ((seq - this->va_) & 7)) % this->max_queue_length_; }
  uint8_t *slot_(uint8_t seq) { return this->tx_slots_ + this->slot_index_(seq) * this->max_packet_size_; }
 
  PacketInterface *lower_;
  // max_queue_length_ slots of max_packet_size_ bytes, a ring starting at head_ which holds frame va_; allocated in
  // setup() and never freed
  uint8_t *tx_slots_{nullptr};
  std::array<uint16_t, MAX_WINDOW> tx_lengths_{};  // indexed like the slots
  uint32_t timeout_ms_{200};
  uint32_t ack_delay_ms_{0};
  uint8_t max_queue_length_{4};
  uint8_t max_retries_{5};
  uint8_t retries_{0};
  uint8_t head_{0};
  uint8_t vs_{0};  // sequence number of the next new frame
  uint8_t vn_{0};  // next frame to send; frames from va_ up to it have been sent
  uint8_t va_{0};  // oldest unacknowledged frame
  uint8_t vr_{0};  // next frame expected from the peer
  LinkState state_{LinkState::LINK_STATE_RESET_PENDING};
  bool ack_pending_{false};  // an RR is owed
  bool ack_due_{false};      // and should be sent now
  bool rej_sent_{false};
  bool peer_frame_seen_{false};  // a numbered frame has arrived since the link came up
  bool oversize_warned_{false};
  bool reset_wait_logged_{false};  // the queue filled while waiting for this reset to be answered
};
 
}  // namespace esphome::packet_interface
#endif