LoRaWAN.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <vector>
#include <array>
#include <string>
#include <functional>
#include <chrono>
#include "SPIInterface.hpp"
 
// LoRaWAN MAC commands
#define MAC_LINK_CHECK_REQ 0x02
#define MAC_LINK_ADR_REQ 0x03
#define MAC_LINK_ADR_ANS 0x03
#define MAC_DUTY_CYCLE_REQ 0x04
#define MAC_DUTY_CYCLE_ANS 0x04
#define MAC_RX_PARAM_SETUP_REQ 0x05
#define MAC_RX_PARAM_SETUP_ANS 0x05
#define MAC_DEV_STATUS_REQ 0x06
#define MAC_DEV_STATUS_ANS 0x06
#define MAC_NEW_CHANNEL_REQ 0x07
#define MAC_NEW_CHANNEL_ANS 0x07
#define MAC_RX_TIMING_SETUP_REQ 0x08
#define MAC_RX_TIMING_SETUP_ANS 0x08
#define MAC_TX_PARAM_SETUP_REQ 0x09
#define MAC_TX_PARAM_SETUP_ANS 0x09
#define MAC_DL_CHANNEL_REQ 0x0A
#define MAC_DL_CHANNEL_ANS 0x0A
#define MAC_REKEY_CONF 0x0B
#define MAC_ADR_PARAM_SETUP_REQ 0x0C
#define MAC_ADR_PARAM_SETUP_ANS 0x0C
#define MAC_DEVICE_TIME_REQ 0x0D
#define MAC_DEVICE_TIME_ANS 0x0D
#define MAC_REJOIN_PARAM_REQ 0x0E
#define MAC_REJOIN_PARAM_ANS 0x0E
#define MAC_PING_SLOT_INFO_REQ 0x10
#define MAC_PING_SLOT_INFO_ANS 0x10
#define MAC_PING_SLOT_CHANNEL_REQ 0x11
#define MAC_PING_SLOT_FREQ_ANS 0x11
#define MAC_BEACON_TIMING_REQ 0x12
#define MAC_BEACON_TIMING_ANS 0x12
#define MAC_BEACON_FREQ_REQ 0x13
#define MAC_BEACON_FREQ_ANS 0x13
#define MAC_LINK_CHECK_ANS 0x02
 
class LoRaWAN {
public:
    enum Region {
        REGION_EU868 = 0, 
        REGION_US915,     
        REGION_AU915,     
        REGION_EU433,     
        REGIONS           
    };
 
    enum DeviceClass {
        CLASS_A, 
        CLASS_B, 
        CLASS_C  
    };
 
    enum JoinMode {
        OTAA, 
        ABP   
    };
 
    enum ConfirmationState {
        NONE,        
        WAITING_ACK, 
        ACK_PENDING  
    };
 
    enum RxWindowState {
        RX_IDLE,        
        RX_WAIT_1,      
        RX_WINDOW_1,    
        RX_WAIT_2,      
        RX_WINDOW_2,    
        RX_CONTINUOUS   
    };
 
    struct Message {
        std::vector<uint8_t> payload; 
        uint8_t port;                 
        bool confirmed;               
    };
 
    typedef std::function<void(const Message&)> ReceiveCallback;
    
    typedef std::function<void(bool)> JoinCallback;
 
    LoRaWAN();
 
    explicit LoRaWAN(std::unique_ptr<SPIInterface> spi_interface);
 
    ~LoRaWAN();
 
    bool init(int deviceIndex = 0);
 
    void setDeviceClass(DeviceClass deviceClass);
 
    void setDevEUI(const std::string& devEUI);
 
    void setAppEUI(const std::string& appEUI);
 
    void setAppKey(const std::string& appKey);
 
    void setDevAddr(const std::string& devAddr);
 
    void setNwkSKey(const std::string& nwkSKey);
 
    void setAppSKey(const std::string& appSKey);
 
    bool join(JoinMode mode, unsigned long timeout = 10000);
 
    std::vector<uint8_t> encryptPayload(const std::vector<uint8_t>& payload, uint8_t port);
 
    std::vector<uint8_t> decryptPayload(const std::vector<uint8_t>& payload, uint8_t port);
 
    float calculateTimeOnAir(size_t payload_size);
 
    bool checkDutyCycle(float frequency, size_t payload_size);
 
    float getDutyCycleUsage(int channel);
 
    void resetDutyCycle();
 
    bool send(const std::vector<uint8_t>& data, uint8_t port, bool confirmed = false, bool force_duty_cycle = false);
 
    void update();
 
    bool receive(Message& message, unsigned long timeout = 1000);
 
    void onReceive(std::function<void(const Message&)> callback);
 
    void onJoin(std::function<void(bool)> callback);
 
    void setRegion(int region);
 
    int getRegion() const;
 
    float getFrequency() const;
 
    void setFrequency(float freq_mhz);
 
    int getChannelFromFrequency(float freq_mhz) const;
 
    float getFrequencyFromChannel(int channel) const;
 
    void setChannel(uint8_t channel);
 
    uint8_t getChannel() const;
 
    void setSingleChannel(bool enable, float freq_mhz = 868.1, int sf = 9, 
                          int bw = 125, int cr = 5, int power = 14, int preamble = 8);
 
    bool getSingleChannel() const;
 
    float getSingleChannelFrequency() const;
 
    void setTxPower(int8_t power);
 
    int getRSSI() const;
 
    int getSNR() const;
 
    uint32_t getFrameCounter() const;
 
    void setFrameCounter(uint32_t counter);
 
    void wake();
 
    void sleep();
 
    bool validateKeys() const;
 
    void enableADR(bool enable);
 
    bool isADREnabled() const;
 
    void resetSession();
 
    void applyADRSettings(uint8_t dataRate, uint8_t txPower, const std::vector<uint8_t>& channelMask);
 
    void processMACCommands(const std::vector<uint8_t>& commands, std::vector<uint8_t>& response);
 
    void processLinkADRReq(const std::vector<uint8_t>& cmd, size_t index, std::vector<uint8_t>& response);
 
    void sendADRStatistics();
 
    void updateTxParamsForADR();
 
    void setupRxWindows();
 
    void openRX1Window();
 
    void openRX2Window();
 
    void updateRxWindows();
 
    void handleConfirmation();
 
    void sendAck();
 
    void resetConfirmationState();
 
    void handleReceivedMessage(const std::vector<uint8_t>& payload, Message& msg);
 
    bool processJoinAccept(const std::vector<uint8_t>& data);
 
    void requestLinkCheck();
 
    void updateDataRateFromSF();
 
    static void setVerbose(bool verbose) { isVerbose = verbose; }
 
    static bool getVerbose() { return isVerbose; }
 
private:
    // Forward declaration of implementation structure
    struct Impl;
    std::unique_ptr<Impl> pimpl;
 
    // Radio parameters for RX windows
    int current_sf;
    float current_bw;
    int current_cr;
    int current_preamble;
    int current_power;
    int current_channel;
    int current_lna;
    int current_sync_word;
    uint8_t current_nbRep;
 
    // RX Window parameters
    uint8_t rx1DrOffset = 0;
    uint8_t rx2DataRate = 0;
 
    // LoRaWAN state and options
    bool joined;
    DeviceClass currentClass;
    JoinMode joinMode;
    bool adrEnabled;
    uint8_t adrAckCounter;
    std::vector<uint8_t> pendingMACResponses;
    
    // Confirmation state variables
    ConfirmationState confirmState = NONE;
    int confirmRetries = 0;
    std::chrono::steady_clock::time_point lastConfirmAttempt;
    std::vector<uint8_t> pendingAck;
    uint8_t ackPort;
    bool needsAck = false;
    uint16_t lastFcntDown = 0;
 
    // Other constants
    static constexpr int MAX_CHANNELS = 16;
    
    // Channels and duty cycle tracking
    float channelFrequencies[MAX_CHANNELS];
    std::chrono::steady_clock::time_point lastChannelUse[MAX_CHANNELS];
    float channelAirTime[MAX_CHANNELS];
 
    // Region selection and constants
    int lora_region = REGION_EU868;
 
    // Single channel mode parameters
    bool one_channel_gateway = false;
    float one_channel_freq = 868.1;
    int one_channel_sf = 9;
    int one_channel_bw = 125;
    int one_channel_cr = 5;
    int one_channel_power = 14;
    int one_channel_preamble = 8;
 
    // Timing constants
    static constexpr unsigned long RECEIVE_DELAY1 = 1000;
    static constexpr unsigned long RECEIVE_DELAY2 = 2000;
    static constexpr unsigned long WINDOW_DURATION = 500;
    
    // ADR constants
    static constexpr uint8_t ADR_ACK_LIMIT = 64;
    static constexpr uint8_t ADR_ACK_DELAY = 32;
    static constexpr uint8_t MAX_RETRIES = 8;
 
    
    // Callbacks
    ReceiveCallback receiveCallback = nullptr;
    JoinCallback joinCallback = nullptr;
 
    // Base frequencies for regions (MHz)
    static constexpr float BASE_FREQ[REGIONS] = { 
        868.1f,  // EU868
        902.3f,  // US915
        915.2f,  // AU915
        433.175f // EU433
    };
 
    // Channel step for regions (MHz)
    static constexpr float CHANNEL_STEP[REGIONS] = {
        0.2f,    // EU868
        0.2f,    // US915
        0.2f,    // AU915
        0.2f     // EU433
    };
 
    // Maximum transmit power by region (dBm)
    static constexpr int MAX_POWER[REGIONS] = {
        14,      // EU868
        30,      // US915
        30,      // AU915
        14       // EU433
    };
 
    // RX2 parameters for each region
    static constexpr float RX2_FREQ[REGIONS] = {
        869.525f, // EU868
        923.3f,   // US915
        923.3f,   // AU915
        434.665f  // EU433
    };
 
    static constexpr int RX2_SF[REGIONS] = {
        9,       // EU868
        12,      // US915
        12,      // AU915
        9        // EU433
    };
 
    static constexpr float RX2_BW[REGIONS] = {
        125.0f,  // EU868
        500.0f,  // US915
        500.0f,  // AU915
        125.0f   // EU433
    };
 
    static constexpr int RX2_CR[REGIONS] = {
        5,       // EU868
        5,       // US915
        5,       // AU915
        5        // EU433
    };
 
    static constexpr int RX2_PREAMBLE[REGIONS] = {
        8,       // EU868
        8,       // US915
        8,       // AU915
        8        // EU433
    };
 
    // Static members
    static bool isVerbose;
 
    // Current data rate
    uint8_t current_dr = 0;
};