ESP32TransceiverStreamIEEE802_15_4.h

Go to the documentation of this file.

#pragma once
 
#include "ESP32TransceiverIEEE802_15_4.h"
#include "RingBuffer.h"
 
namespace ieee802154 {
 
class ESP32TransceiverStreamIEEE802_15_4 : public Stream {
 public:
  ESP32TransceiverStreamIEEE802_15_4(ESP32TransceiverIEEE802_15_4& transceiver)
      : p_transceiver(&transceiver) {
    transceiver.setReceiveTask(nullptr);
    owns_transceiver = false;
  }
 
  ESP32TransceiverStreamIEEE802_15_4(channel_t channel, int16_t panID,
                                     Address localAdr) {
    p_transceiver = new ESP32TransceiverIEEE802_15_4(channel, panID, localAdr);
    p_transceiver->setReceiveTask(nullptr);
    owns_transceiver = true;
  }
 
  ~ESP32TransceiverStreamIEEE802_15_4() {
    if (owns_transceiver) {
      delete p_transceiver;
    }
  }
 
  FrameControlField& getFrameControlField() {
    return p_transceiver->getFrameControlField();
  }
 
  size_t getRxBufferSize() const { return rx_buffer.size(); }
 
  int getRxMessageBufferSize() const { return receive_msg_buffer_size; }
 
  int getSendDelay() const { return send_delay_ms; }
 
  bool setRxWhenIdleActive(bool rx_when_idle) {
    return p_transceiver->setRxWhenIdleActive(rx_when_idle);
  }
 
  void setFrameControlField(const FrameControlField& fcf) {
    p_transceiver->setFrameControlField(fcf);
  }
 
  void setDestinationAddress(const Address& address) {
    p_transceiver->setDestinationAddress(address);
  }
 
  void setAckTimeoutUs(uint32_t timeout_us) {
    p_transceiver->setAckTimeoutUs(timeout_us);
  }
 
  uint32_t getAckTimeoutUs() const { return p_transceiver->getAckTimeoutUs(); }
 
  void setAckActive(bool ack_active) {
    // Set the acknowledgment request bit in the Frame Control Field
    p_transceiver->getFrameControlField().ackRequest = ack_active;
  }
 
  bool isAckActive() const {
    return p_transceiver->getFrameControlField().ackRequest == 1;
  }
 
  void setRxBufferSize(size_t size) { rx_buffer.resize(size); }
 
  void setRxMessageBufferSize(int size) {
    receive_msg_buffer_size = size;
    p_transceiver->setReceiveBufferSize(size);
  }
 
  void setSendDelay(int delay_ms) { send_delay_ms = delay_ms; }
 
  void setSendRetryCount(int count) { send_retry_count = count; }
 
  void setCCAActive(bool cca_enabled) {
    p_transceiver->setCCAActive(cca_enabled);
  }
 
  bool isCCAActive() const { return p_transceiver->isCCAActive(); }
 
  bool begin() {
    is_open_frame = false;
    last_seq = -1;
    if (p_transceiver == nullptr) {
      return false;  // Cannot begin without a transceiver
    }
    // use no separate task!
    p_transceiver->setAutoIncrementSequenceNumber(false);
    p_transceiver->setReceiveTask(nullptr);
    p_transceiver->setReceiveBufferSize(
        receive_msg_buffer_size);  // Set default message buffer size
    setRxBufferSize(1024);
    p_transceiver->setTxDoneCallback(ieee802154_transceiver_tx_done_callback,
                                     this);
    p_transceiver->setTxFailedCallback(
        ieee802154_transceiver_tx_failed_callback, this);
    // start with 1;
    p_transceiver->incrementSequenceNumber(1);
 
    return p_transceiver->begin();
  }
 
  bool begin(FrameControlField fcf) {
    p_transceiver->setFrameControlField(fcf);
    return begin();
  }
 
  void end() { p_transceiver->end(); }
 
  size_t write(const uint8_t* buffer, size_t size) override {
    size_t written = 0;
    for (size_t i = 0; i < size; i++) {
      if (write(buffer[i]) == 1) {
        written++;
      } else {
        break;  // Stop if we can't write more
      }
    }
    if (size < MTU) flush();
    return written;
  }
 
  size_t write(const uint8_t byte) override {
    bool rc = tx_buffer.write(byte);
    if (tx_buffer.isFull()) {
      flush();
    }
    return rc ? 1 : 0;
  }
  int read() override {
    receive();
    return rx_buffer.read();
  }
 
  size_t readBytes(uint8_t* buffer, size_t size) {
    // fill receive buffer
    uint32_t end = millis() + _timeout;
    while (receive() && millis() < end);
    // provide data from receive buffer
    return rx_buffer.readArray(buffer, size);
  }
 
  int peek() {
    if (rx_buffer.isEmpty()) receive();
    uint8_t c = 0;
    bool rc = rx_buffer.peek(c);
    return rc ? c : -1;
  }
 
  virtual int available() override { return rx_buffer.available(); }
 
  int availableForWrite() override { return 1024; }
 
  void flush() override {
    // get data from buffer
    if (isSendConfirmations()) {
      sendWithConfirmations();
    } else {
      sendWithoutConfirmations();
    }
  }
 
  channel_t getChannel() const { return p_transceiver->getChannel(); }
 
  bool setChannel(channel_t channel) {
    return p_transceiver->setChannel(channel);
  }
 
  int8_t getTxPower() const { return p_transceiver->getTxPower(); }
 
  bool setTxPower(int power) { return p_transceiver->setTxPower(power); }
 
  bool setCoordinatorActive(bool coordinator) {
    return p_transceiver->setCoordinatorActive(coordinator);
  }
 
  bool setPromiscuousModeActive(bool promiscuous) {
    return p_transceiver->setPromiscuousModeActive(promiscuous);
  }
 
  void setBroadcast() { p_transceiver->setBroadcast(); }
 
  ESP32TransceiverIEEE802_15_4& getTransceiver() { return *p_transceiver; }
 
  int getMaxMTU() const { return MTU; }
 
  bool setTxBufferSize(int buffer_size) {
    if (buffer_size > 0 && buffer_size <= getMaxMTU()) {
      tx_buffer.resize(buffer_size);
      return true;
    }
    ESP_LOGE(TAG, "Invalid TX buffer size: %d. Must be between 1 and %d.",
             buffer_size, getMaxMTU());
    return false;  // Invalid MTU size
  }
 
  int getTxBufferSize() const { return tx_buffer.size(); }
 
 
 protected:
  static constexpr const char* TAG = "ESP32TransceiverStream";
  static constexpr int MTU = 116;
  int receive_msg_buffer_size =
      (sizeof(frame_data_t) + 4) * 100;  // Default size for message buffer
  ESP32TransceiverIEEE802_15_4* p_transceiver = nullptr;
  bool owns_transceiver = false;
  RingBuffer rx_buffer{1024 + MTU};
  RingBuffer tx_buffer{MTU};
  Frame frame;  // For parsing and buffering received frames
  bool is_open_frame = false;
  enum send_confirmation_state_t {
    WAITING_FOR_CONFIRMATION,
    CONFIRMATION_RECEIVED,
    CONFIRMATION_ERROR,
  };
  volatile send_confirmation_state_t send_confirmation_state =
      WAITING_FOR_CONFIRMATION;
  bool is_send_confirations_enabled = false;
  bool is_auto_flush = false;
  int send_delay_ms = 10;
  int last_seq = -1;
  int send_retry_count = 2;
  esp_ieee802154_tx_error_t last_tx_error = ESP_IEEE802154_TX_ERR_NONE;
 
  bool isSendConfirmations() { return getFrameControlField().ackRequest == 1; }
 
  bool isSequenceNumbers() {
    return getFrameControlField().sequenceNumberSuppression == 0;
  }
 
  bool receive() {
    frame_data_t packet;  // Temporary storage for received frame data
    if (is_open_frame) {
      // We have a pending frame that we haven't processed yet
      if (frame.payloadLen > rx_buffer.availableForWrite()) {
        delay(10);
        return false;
      }
      // Store payload in receive buffer
      rx_buffer.writeArray(frame.payload, frame.payloadLen);
      is_open_frame = false;  // Mark frame as processed
      return true;
    }
 
    // get next frame
    size_t read_bytes = 0;
    read_bytes =
        xMessageBufferReceive(p_transceiver->getMessageBuffer(), &packet,
                              sizeof(frame_data_t), pdMS_TO_TICKS(20));
    if (read_bytes != sizeof(frame_data_t)) {
      if (read_bytes != 0) {
        ESP_LOGE(TAG, "Invalid packet size received: %d", read_bytes);
      }
      return false;
    }
 
    // Parse frame
    if (!frame.parse(packet.frame, false)) {
      ESP_LOGE(TAG, "Failed to parse frame");
      return false;
    }
 
    ESP_LOGI(TAG, "Received frame: len=%d, seq=%d", frame.payloadLen,
             frame.sequenceNumber);
 
    // Sequence number check (after successful parse, before buffer handling)
    if (isSequenceNumbers()) {
      int seq = frame.sequenceNumber;
      if (last_seq != -1) {
        int expected = (last_seq + 1) % 256;
        if (seq == last_seq) {
          ESP_LOGI(TAG, "Retransmission ignored: seq %d", seq);
          return false;  // Ignore duplicate
        } else if (seq != expected) {
          ESP_LOGI(TAG, "Frame sequence skipped: expected %d, got %d", expected,
                   seq);
          // Accept the new frame, but log the skip
        }
      }
      last_seq = seq;
    }
 
    if (frame.payloadLen > rx_buffer.availableForWrite()) {
      // will be made availabe with next call
      ESP_LOGD(TAG, "Received frame payload too large for buffer: %d bytes",
               frame.payloadLen);
      is_open_frame = true;
      return false;
    }
 
    // Store payload in receive buffer
    rx_buffer.writeArray(frame.payload, frame.payloadLen);
    delay(5);
 
    return true;
  }
 
  void sendWithConfirmations() {
    uint8_t tmp[tx_buffer.available()];
    int len = tx_buffer.readArray(tmp, tx_buffer.available());
    int retry = send_retry_count;
    // send frame
    int attempt = 0;
    do {
      // send data
      send_confirmation_state = WAITING_FOR_CONFIRMATION;
      ESP_LOGD(TAG, "Attempt %d: Sending frame, len: %d", attempt, len);
      if (!p_transceiver->send(tmp, len)) {
        ESP_LOGE(TAG, "Failed to send frame: size %d", len);
        send_confirmation_state = CONFIRMATION_ERROR;
      }
 
      // wait for confirmations
      uint32_t timeout =
          millis() + (getAckTimeoutUs() / 1000) + 2;  // Add some margin
      while (send_confirmation_state == WAITING_FOR_CONFIRMATION &&
             millis() < timeout) {
        delay(2);
      }
 
      // on error retry sending the same frame
      switch (send_confirmation_state) {
        case CONFIRMATION_ERROR: {
          ESP_LOGI(TAG, "Send failed with rc=%d, retrying...", last_tx_error);
          retry--;
          if (retry <= 0) {
            // abort retry and move to next frame
            p_transceiver->incrementSequenceNumber(1);
            delay(send_delay_ms);
            return;
          }
          // Short delay before retrying
          delay(send_delay_ms);
          break;
        }
        case CONFIRMATION_RECEIVED: {
          p_transceiver->incrementSequenceNumber(1);
          delay(send_delay_ms);
          break;
        }
        default:
          // we should not be here, but if we are, we just retry
          retry--;
          delay(send_delay_ms);  // Short delay before retrying if needed
          break;
      }
      ++attempt;
    } while (send_confirmation_state == CONFIRMATION_ERROR);
  }
 
  void sendWithoutConfirmations() {
    uint8_t tmp[tx_buffer.available()];
    int len = tx_buffer.readArray(tmp, tx_buffer.available());
    ESP_LOGD(TAG, "Sending frame, len: %d", len);
    if (p_transceiver->send(tmp, len)) {
      p_transceiver->incrementSequenceNumber(1);
    } else {
      ESP_LOGE(TAG, "Failed to send frame: size %d", len);
    }
    delay(send_delay_ms);
  }
 
  static void ieee802154_transceiver_tx_done_callback(
      const uint8_t* frame, const uint8_t* ack,
      esp_ieee802154_frame_info_t* ack_frame_info, void* user_data) {
    ESP32TransceiverStreamIEEE802_15_4& self =
        *static_cast<ESP32TransceiverStreamIEEE802_15_4*>(user_data);
    self.send_confirmation_state = CONFIRMATION_RECEIVED;
    self.last_tx_error = ESP_IEEE802154_TX_ERR_NONE;
  }
 
  static void ieee802154_transceiver_tx_failed_callback(
      const uint8_t* frame, esp_ieee802154_tx_error_t error, void* user_data) {
    ESP32TransceiverStreamIEEE802_15_4& self =
        *static_cast<ESP32TransceiverStreamIEEE802_15_4*>(user_data);
    self.send_confirmation_state = CONFIRMATION_ERROR;
    self.last_tx_error = error;
  }
};
 
using ESP32TransceiverIEEE802_15_4Stream = ESP32TransceiverStreamIEEE802_15_4;
 
}  // namespace ieee802154