LoRaWANPacMan.h

#if !defined(_RADIOLIB_LORAWAN_PACMAN_H) && !RADIOLIB_EXCLUDE_LORAWAN
#define _RADIOLIB_LORAWAN_PACMAN_H
 
#include "LoRaWAN.h"
 
// Number of known TSxxx packages
#define RADIOLIB_LORAWAN_NUM_PACKAGES           (8)
 
// Package ID numbering as per TS008 (TS011 ID is made up)
#define RADIOLIB_LORAWAN_PACKAGE_TS003                          (1)
#define RADIOLIB_LORAWAN_PACKAGE_TS004                          (3)
#define RADIOLIB_LORAWAN_PACKAGE_TS005                          (2)
#define RADIOLIB_LORAWAN_PACKAGE_TS006                          (4)
#define RADIOLIB_LORAWAN_PACKAGE_TS007                          (0)
#define RADIOLIB_LORAWAN_PACKAGE_TS009                          (5)
#define RADIOLIB_LORAWAN_PACKAGE_TS011                          (6)
 
// Package FPort (specified or recommended)
#define RADIOLIB_LORAWAN_FPORT_TS003                            (202)
#define RADIOLIB_LORAWAN_FPORT_TS004                            (201)
#define RADIOLIB_LORAWAN_FPORT_TS005                            (200)
#define RADIOLIB_LORAWAN_FPORT_TS006                            (203)
#define RADIOLIB_LORAWAN_FPORT_TS007                            (225)
#define RADIOLIB_LORAWAN_FPORT_TS009                            (224)
#define RADIOLIB_LORAWAN_FPORT_TS011                            (226)
 
// TS007 Multi-Package Access package (PackageIdentifier 0) commands and constants
#define RADIOLIB_LORAWAN_TS007_CID_PKG_VERSION                  (0x00)
#define RADIOLIB_LORAWAN_TS007_CID_DEV_PACKAGE                  (0x01)
#define RADIOLIB_LORAWAN_TS007_CID_MULTI_PACK_BUFFER            (0x02)
#define RADIOLIB_LORAWAN_TS007_PACKAGE_VERSION_NUM              (1)
#define RADIOLIB_LORAWAN_TS007_ERROR                            (0xFF)
 
// A PackageID field has bit 7 set; CommandIDs are always < 128
#define RADIOLIB_LORAWAN_TS007_PACKAGE_ID_FLAG                  (0x80)
 
// Maximum size of the ANS buffer (TS007 section 3.1)
#define RADIOLIB_LORAWAN_TS007_ANS_BUFFER_SIZE                  (128)
 
// Forward-declare the manager so it can be friended by LoRaWANPackage
class LoRaWANPackageManager;

class LoRaWANPackage {
  public:
 
    typedef RadioLibTime_t (*GetSecondsCb_t)();
 
    // copy constructor is removed to prevent users from creating copies of this class
    LoRaWANPackage(const LoRaWANPackage& obj) = delete;

    virtual size_t processData(const uint8_t* dataIn, size_t lenIn, uint8_t* dataOut, size_t* lenOut, LoRaWANEvent_t* event);

    virtual bool handleTask(RadioLibTime_t* tNext, bool* uplinkDue);

    virtual size_t buildUplink(uint8_t* dataOut);

    RadioLibTime_t getSeconds() {
      if(this->getSeconds_cb != NULL) {
        return(this->getSeconds_cb());
      }
      return(0);
    }
 
#if !RADIOLIB_GODMODE
  protected:
#endif

    LoRaWANPackage(uint8_t ts, LoRaWANPackageManager* pacMan, RadioLibHal* hal, LoRaWANNode* node, GetSecondsCb_t secondsCb);
 
    uint8_t packageIdentifier;
    uint8_t packageVersion;
 
    LoRaWANPackageManager* pacMan;
    RadioLibHal* hal;
    LoRaWANNode* lorawanNode;
    GetSecondsCb_t getSeconds_cb;
 
    // allow LoRaWANPackageManager to access the protected members
    friend LoRaWANPackageManager;
};

class LoRaWANPackageManager {
  public:
 
    typedef RadioLibTime_t (*GetSecondsCb_t)();
    typedef void (*SetSecondsCb_t)(RadioLibTime_t seconds);
    typedef void (*DelaySecondsCb_t)(RadioLibTime_t seconds);
    typedef void (*UplinkIntervalCb_t)(RadioLibTime_t intervalSeconds);
    typedef void (*ConfirmedCb_t)(bool confirmed);
    typedef void (*RebootCb_t)();
    
    LoRaWANPackageManager(RadioLibHal* hal, LoRaWANNode* node, GetSecondsCb_t secondsCb);
 
    // Package enable methods
    int16_t enableTS003(uint8_t fPort, SetSecondsCb_t setSecondsFunc);

    int16_t enableTS007();

    int16_t enableTS009(PhysicalLayer* radio, DelaySecondsCb_t delayCb, UplinkIntervalCb_t intervalCb, ConfirmedCb_t confirmedCb, RebootCb_t rebootCb);
 
    // TS003
    void requestAppTime();

    int16_t processDownlink(const uint8_t* data, size_t len, LoRaWANEvent_t* eventDown);

    bool handleTask(RadioLibTime_t* tNext);

    bool getUplinkData(uint8_t* dataOut, size_t* lenOut, uint8_t* fPort);
 
    bool isEnabledFPort(uint8_t fPort) {
      for(uint8_t i = 0; i < RADIOLIB_LORAWAN_NUM_PACKAGES; i++) {
        if(this->enabledPackages[i] && this->packagePorts[i] == fPort) {
          return(true);
        }
      }
      return(false);
    }
    
#if !RADIOLIB_GODMODE
  protected:
#endif
 
    // Set up transmission of a MultiPackBufferReq answer (TS007 section 4.4).
    // Uses the persistent ANS buffer; sets the transmit cursor or the error flag.
    void handleMultiPackBufferReq(uint8_t startByte, uint8_t stopByte);
 
    // Process the TS007 multi-package access package's own commands
    // (PackageVersionReq, DevPackageReq).
    size_t processPackageManagerData(const uint8_t* dataDown, size_t lenDown, uint8_t* ansOut, size_t* ansLen);
 
    RadioLibHal* hal;
    LoRaWANNode* lorawanNode;
    LoRaWANPackage* packages[RADIOLIB_LORAWAN_NUM_PACKAGES];
    uint8_t packagePorts[RADIOLIB_LORAWAN_NUM_PACKAGES];
    bool enabledPackages[RADIOLIB_LORAWAN_NUM_PACKAGES];
 
    // Time handler functions
    GetSecondsCb_t getSecondsCb;
 
    // Staging buffer for a plain (non multi-package) uplink: a dedicated-FPort answer
    // or a scheduled package uplink. Packages write here (via the dataOut buffer they
    // are handed); it is overwritten on each newly staged uplink.
    uint8_t ansBuffer[255] = { 0 };
    size_t ansBufferLen = 0;
    uint8_t ansFPort = 0;         // FPort on which the staged uplink will be sent (225 = TS007)
 
    // Persistent TS007 ANS buffer (answers only, no Command Token). Kept in memory for
    // on-demand retransmission via MultiPackBufferReq until a new multi-package command
    // set is received. Separate from ansBuffer.
    uint8_t ts007Buffer[RADIOLIB_LORAWAN_TS007_ANS_BUFFER_SIZE] = { 0 };
    size_t ts007BufferLen = 0;
    uint8_t commandToken = 0;     // TS007 Command Token to append to FPort 225 uplinks
 
    // Transmission state for a pending uplink (TS007 fragments are sent over several
    // calls; a plain package uplink is sent in one)
    bool pendingUplink = false;   // a staged uplink is due now
    uint8_t pendingPackage = 0;   // package index that builds its uplink at send time
    size_t txCursor = 0;          // next BaseByte to transmit (TS007 fragmentation)
    size_t txStop = 0;            // last TS007 ANS buffer index to transmit (inclusive)
    bool sendFragmented = false;  // always wrap in MultiPackBufferFrag (Req response)
    bool indexError = false;      // next uplink is the [0x02][0xFF] error frame
 
};
 
#endif