ESP32TransceiverIEEE802_15_4.h

Go to the documentation of this file.

#pragma once
// make sure that logging works in Arduino environment
#ifdef ARDUINO
#include "Arduino.h"
#endif
 
#include <esp_ieee802154.h>
#include <esp_log.h>
#include <stdint.h>
 
#include "Frame.h"  // From shoderico/ieee802154_frame
#include "esp_err.h"
#include "esp_ieee802154.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "nvs_flash.h"
 
namespace ieee802154 {
 
// forward declaration
class ESP32TransceiverIEEE802_15_4;
extern ESP32TransceiverIEEE802_15_4* pt_transceiver;
 
enum class channel_t : uint8_t {
  UNDEFINED = 0,
  CHANNEL_11 = 11,
  CHANNEL_12 = 12,
  CHANNEL_13 = 13,
  CHANNEL_14 = 14,
  CHANNEL_15 = 15,
  CHANNEL_16 = 16,
  CHANNEL_17 = 17,
  CHANNEL_18 = 18,
  CHANNEL_19 = 19,
  CHANNEL_20 = 20,
  CHANNEL_21 = 21,
  CHANNEL_22 = 22,
  CHANNEL_23 = 23,
  CHANNEL_24 = 24,
  CHANNEL_25 = 25,
  CHANNEL_26 = 26
};
 
typedef void (*ieee802154_transceiver_rx_callback_t)(
    Frame& frame, esp_ieee802154_frame_info_t& frame_info, void* user_data);
 
typedef void (*ieee802154_transceiver_tx_done_callback_t)(
    const uint8_t* frame, const uint8_t* ack,
    esp_ieee802154_frame_info_t* ack_frame_info, void* user_data);
 
typedef void (*ieee802154_transceiver_tx_failed_callback_t)(
    const uint8_t* frame, esp_ieee802154_tx_error_t error, void* user_data);
 
typedef void (*ieee802154_transceiver_sfd_callback_t)(void* user_data);
 
typedef void (*ieee802154_transceiver_sfd_tx_callback_t)(uint8_t* frame,
                                                         void* user_data);
inline Address BROADCAST_ADDRESS((uint8_t[2]){0xFF, 0xFF});
 
class ESP32TransceiverIEEE802_15_4 {
  // Friend declarations for global callback functions
  friend void receive_packet_task(void*);
  friend void ::esp_ieee802154_receive_done(
      uint8_t* frame, esp_ieee802154_frame_info_t* frame_info);
  friend void ::esp_ieee802154_transmit_done(
      const uint8_t* frame, const uint8_t* ack,
      esp_ieee802154_frame_info_t* ack_frame_info);
  friend void ::esp_ieee802154_transmit_failed(const uint8_t* frame,
                                               esp_ieee802154_tx_error_t error);
  friend void ::esp_ieee802154_receive_sfd_done(void);
  friend void ::esp_ieee802154_transmit_sfd_done(uint8_t* frame);
 
 public:
  ESP32TransceiverIEEE802_15_4(channel_t channel, int16_t panID,
                               Address localAddress) {
    this->channel = channel;
    this->panID = panID;
    this->local_address = localAddress;
    pt_transceiver = this;
  }
 
  bool begin();
 
  bool begin(FrameControlField fcf) {
    setFrameControlField(fcf);
    return begin();
  }
 
  bool end(void);
 
  bool setRxCallback(ieee802154_transceiver_rx_callback_t callback,
                     void* user_data);
 
  bool setTxDoneCallback(ieee802154_transceiver_tx_done_callback_t callback,
                         void* user_data);
 
  bool setTxFailedCallback(ieee802154_transceiver_tx_failed_callback_t callback,
                           void* user_data);
 
  bool setSfdCallback(ieee802154_transceiver_sfd_callback_t callback,
                      void* user_data);
 
  bool setSfdTxCallback(ieee802154_transceiver_sfd_tx_callback_t callback,
                        void* user_data);
  bool send(uint8_t* data, size_t len);
 
  bool send(Frame& frame);
 
  bool setChannel(channel_t channel);
 
  channel_t getChannel() const { return channel; }
 
  esp_ieee802154_pending_mode_t getPendingMode() {
    return ::esp_ieee802154_get_pending_mode();
  }
 
  int8_t getTxPower() { return ::esp_ieee802154_get_txpower(); }
 
  bool setTxPower(int power);
 
  bool isCoordinatorActive() const { return is_coordinator; }
 
  bool setCoordinatorActive(bool coordinator);
 
  bool isPromiscuousModeActive() const { return is_promiscuous_mode; }
 
  bool setPromiscuousModeActive(bool promiscuous);
 
  bool isRxWhenIdleActive() const { return is_rx_when_idle; }
 
  bool setRxWhenIdleActive(bool rx_when_idle);
 
  void setDestinationAddress(const Address& address) {
    destination_address = address;
  }
 
  void setBroadcast() { setDestinationAddress(BROADCAST_ADDRESS); }
 
  void setFrameControlField(const FrameControlField& fcf) {
    frame_control_field = fcf;
  }
 
  FrameControlField& getFrameControlField() { return frame_control_field; }
 
  /***
   * @brief Get a reference to the actual frame object that is used for
   * sending..
   * @return Reference to the current Frame object.
   */
  Frame& getFrame() { return frame; }
 
  void setReceiveTask(void (*task)(void* pvParameters)) {
    receive_packet_task = task;
  }
 
  /***
   * @brief Defines the receive buffer size for incoming frames.
   * @param size The size of the receive buffer in bytes.
   * @note This method must be called before begin() to take effect!
   */
  void setReceiveBufferSize(int size);
  StreamBufferHandle_t getMessageBuffer() const { return message_buffer; }
 
  void incrementSequenceNumber(int n = 1) {
    frame.sequenceNumber += n;
    // Ensure the sequence number wraps around at 255
    frame.sequenceNumber = frame.sequenceNumber % 256;
  }
 
  void setAutoIncrementSequenceNumber(bool auto_increment) {
    auto_increment_sequence_number = auto_increment;
  }
 
  void setAckTimeoutUs(uint32_t timeout_us) {
    ack_timeout_us = timeout_us / 16 * 16;  // Round to nearest multiple of 16
  }
 
  uint32_t getAckTimeoutUs() const { return ack_timeout_us; }
 
  void setCCAActive(bool cca_enabled) { this->cca_enabled = cca_enabled; }
 
  bool isCCAActive() const { return cca_enabled; }
 
 protected:
  bool is_promiscuous_mode = false;
  bool is_coordinator = false;
  bool is_rx_when_idle = true;
  bool is_active = false;
  // current frame
  Frame frame;
  channel_t channel = channel_t::UNDEFINED;
  int16_t panID;          // Personal Area Network Identifier
  Address local_address;  // Local address for filtering (0, 2, or 8 bytes)
  Address destination_address = BROADCAST_ADDRESS;
  FrameControlField frame_control_field{};
  uint8_t transmit_buffer[MAX_FRAME_LEN] = {0};
  StreamBufferHandle_t message_buffer = nullptr;
  TaskHandle_t rx_task_handle = nullptr;
  bool radio_enabled = false;
  ieee802154_transceiver_rx_callback_t rx_callback_ = nullptr;
  void* rx_callback_user_data_ = nullptr;
  ieee802154_transceiver_tx_done_callback_t tx_done_callback_ = nullptr;
  void* tx_done_callback_user_data_ = nullptr;
  ieee802154_transceiver_tx_failed_callback_t tx_failed_callback_ = nullptr;
  void* tx_failed_callback_user_data_ = nullptr;
  ieee802154_transceiver_sfd_callback_t sfd_callback_ = nullptr;
  void* sfd_callback_user_data_ = nullptr;
  ieee802154_transceiver_sfd_tx_callback_t sfd_tx_callback_ = nullptr;
  void* sfd_tx_callback_user_data_ = nullptr;
  static void default_receive_packet_task(void* pvParameters);
  void (*receive_packet_task)(void* pvParameters) = default_receive_packet_task;
  int receive_msg_buffer_size = sizeof(frame_data_t) + 4;
  uint32_t ack_timeout_us = (2016 * 16);
  bool auto_increment_sequence_number = true;
  bool cca_enabled = false;
 
  esp_err_t transmit_frame(Frame* frame);
  void onRxDone(uint8_t* frame, esp_ieee802154_frame_info_t* frame_info);
  void onTransmitDone(const uint8_t* frame, const uint8_t* ack,
                      esp_ieee802154_frame_info_t* ack_frame_info);
  void onTransmitFailed(const uint8_t* frame, esp_ieee802154_tx_error_t error);
  void onStartFrameDelimiterReceived();
  void onStartFrameDelimiterTransmitDone(uint8_t* frame);
};
 
}  // namespace ieee802154
 
#ifdef ARDUINO
using namespace ieee802154;
#endif