LoraMesher.h

#ifndef _LORAMESHER_H
#define _LORAMESHER_H
 
// LoRa libraries
#include "RadioLib.h"
 
// Logger
#include <ArduinoLog.h>
//#define DISABLE_LOGGING
 
//Actual LoRaMesher Libraries
#include "BuildOptions.h"
 
#include "utilities/LinkedQueue.hpp"
 
#include "services/PacketService.h"
 
#include "services/RoutingTableService.h"
 
#include "services/PacketQueueService.h"
 
#include "services/WiFiService.h"
 
class LoraMesher {
 
public:
    static LoraMesher& getInstance() {
        static LoraMesher instance;
        return instance;
    }
 
    void begin(float freq = LM_BAND, float bw = LM_BANDWIDTH, uint8_t sf = LM_LORASF, uint8_t cr = LM_CODING_RATE, uint8_t syncWord = LM_SYNC_WORD, int8_t power = LM_POWER, uint16_t preambleLength = LM_PREAMBLE_LENGTH);
 
    [[deprecated("Use begin(...) instead. Will be deleted permanently in v0.0.6.")]]
    void init(void (*receiverFunction)(void*));
 
    void start();
 
    void standby();
 
    ~LoraMesher();
 
    void setFrequency(float freq) { radio->setFrequency(freq); recalculateMaxTimeOnAir(); }
 
    void setBandwidth(float bw) { radio->setBandwidth(bw); recalculateMaxTimeOnAir(); }
 
    void setSpreadingFactor(uint8_t sf) { radio->setSpreadingFactor(sf); recalculateMaxTimeOnAir(); }
 
    void setCodingRate(uint8_t cr) { radio->setCodingRate(cr); recalculateMaxTimeOnAir(); }
 
    void setOutputPower(int8_t power, bool useRfo = false) { radio->setOutputPower(power, useRfo); }
 
    void setReceiveAppDataTaskHandle(TaskHandle_t ReceiveAppDataTaskHandle) { ReceiveAppData_TaskHandle = ReceiveAppDataTaskHandle; }
 
    LM_LinkedList<RouteNode>* routingTableList() { return RoutingTableService::routingTableList; }
 
    template <typename T>
    void createPacketAndSend(uint16_t dst, T* payload, uint8_t payloadSize) {
        //Cannot send an empty packet
        if (payloadSize == 0)
            return;
 
        //Get the size of the payload in bytes
        size_t payloadSizeInBytes = payloadSize * sizeof(T);
 
        //Create a data packet with the payload
        DataPacket* dPacket = PacketService::createDataPacket(dst, getLocalAddress(), DATA_P, reinterpret_cast<uint8_t*>(payload), payloadSizeInBytes);
 
        //Create the packet and set it to the send queue
        setPackedForSend(reinterpret_cast<Packet<uint8_t>*>(dPacket), DEFAULT_PRIORITY);
    }
 
    void sendReliablePacket(uint16_t dst, uint8_t* payload, uint32_t payloadSize);
 
    template <typename T>
    void sendReliable(uint16_t dst, T* payload, uint32_t payloadSize) {
        sendReliablePacket(dst, reinterpret_cast<uint8_t*>(payload), sizeof(T) * payloadSize);
    }
 
    size_t getReceivedQueueSize();
 
    size_t getSendQueueSize();
 
    template<typename T>
    AppPacket<T>* getNextAppPacket() {
        ReceivedAppPackets->setInUse();
        AppPacket<T>* appPacket = reinterpret_cast<AppPacket<T>*>(ReceivedAppPackets->Pop());
        ReceivedAppPackets->releaseInUse();
        return appPacket;
    }
 
    template <typename T>
    static void deletePacket(AppPacket<T>* p) {
        delete p;
    }
 
    int routingTableSize();
 
 
    uint16_t getLocalAddress();
 
    uint32_t getReceivedDataPacketsNum() { return receivedDataPacketsNum; }
 
    uint32_t getSendPacketsNum() { return sendPacketsNum; }
 
    uint32_t getReceivedHelloPacketsNum() { return receivedHelloPacketsNum; }
 
    uint32_t getSentHelloPacketsNum() { return sentHelloPacketsNum; }
 
    uint32_t getReceivedBroadcastPacketsNum() { return receivedBroadcastPacketsNum; }
 
    uint32_t getForwardedPacketsNum() { return forwardedPacketsNum; }
 
    uint32_t getDataPacketsForMeNum() { return dataPacketForMeNum; }
 
    uint32_t getReceivedIAmViaNum() { return receivedIAmViaNum; }
 
    uint32_t getDestinyUnreachableNum() { return sendPacketDestinyUnreachableNum; }
 
    uint32_t getReceivedNotForMe() { return receivedPacketNotForMeNum; }
 
 
private:
 
    LoraMesher();
 
    LM_LinkedList<AppPacket<uint8_t>>* ReceivedAppPackets = new LM_LinkedList<AppPacket<uint8_t>>();
 
    LM_LinkedList<QueuePacket<Packet<uint8_t>>>* ReceivedPackets = new LM_LinkedList<QueuePacket<Packet<uint8_t>>>();
 
    LM_LinkedList<QueuePacket<Packet<uint8_t>>>* ToSendPackets = new LM_LinkedList<QueuePacket<Packet<uint8_t>>>();
 
    SX1276* radio;
 
    Module* genericModule;
 
    TaskHandle_t Hello_TaskHandle = nullptr;
 
    TaskHandle_t ReceivePacket_TaskHandle = nullptr;
 
    TaskHandle_t ReceiveData_TaskHandle = nullptr;
 
    TaskHandle_t SendData_TaskHandle = nullptr;
 
    TaskHandle_t ReceiveAppData_TaskHandle = nullptr;
 
    TaskHandle_t PacketManager_TaskHandle = nullptr;
 
    static void onReceive(void);
 
    void receivingRoutine();
 
    void initializeLoRa(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power, uint16_t preambleLength);
 
    void initializeSchedulers();
 
    //TODO: Change message
    [[deprecated("Create task and add it to the LoRaMesher using the function setReceiveAppDataTaskHandle(...). Will be deleted permanently in v0.0.6.")]]
    void initializeReceivedUserDataTask(void (*func)(void*));
 
    void sendHelloPacket();
 
    void packetManager();
 
 
    uint32_t receivedDataPacketsNum = 0;
    void incReceivedDataPackets() { receivedDataPacketsNum++; }
 
    uint32_t sendPacketsNum = 0;
    void incSendPackets() { sendPacketsNum++; }
 
    uint32_t receivedHelloPacketsNum = 0;
    void incRecHelloPackets() { receivedHelloPacketsNum++; }
 
    uint32_t sentHelloPacketsNum = 0;
    void incSentHelloPackets() { sentHelloPacketsNum++; }
 
    uint32_t receivedBroadcastPacketsNum = 0;
    void incReceivedBroadcast() { receivedBroadcastPacketsNum++; }
 
    uint32_t forwardedPacketsNum = 0;
    void incForwardedPackets() { forwardedPacketsNum++; }
 
    uint32_t dataPacketForMeNum = 0;
    void incDataPacketForMe() { dataPacketForMeNum++; }
 
    uint32_t receivedIAmViaNum = 0;
    void incReceivedIAmVia() { receivedIAmViaNum++; }
 
    uint32_t sendPacketDestinyUnreachableNum = 0;
    void incDestinyUnreachable() { sendPacketDestinyUnreachableNum++; }
 
    uint32_t receivedPacketNotForMeNum = 0;
    void incReceivedNotForMe() { receivedPacketNotForMeNum++; }
 
    void processPackets();
 
    template <typename T>
    static void deletePacket(Packet<T>* p) {
        free(p);
    }
 
    void setPackedForSend(Packet<uint8_t>* p, uint8_t priority) {
        Log.traceln(F("Adding packet to Q_SP"));
        QueuePacket<Packet<uint8_t>>* send = PacketQueueService::createQueuePacket(p, priority);
        Log.traceln(F("Created packet to Q_SP"));
        addToSendOrderedAndNotify(send);
        //TODO: Using vTaskDelay to kill the packet inside LoraMesher
    }
 
    void addToSendOrderedAndNotify(QueuePacket<Packet<uint8_t>>* qp);
 
    void processDataPacket(QueuePacket<DataPacket>* pq);
 
    void processDataPacketForMe(QueuePacket<DataPacket>* pq);
 
    void notifyUserReceivedPacket(AppPacket<uint8_t>* appPq);
 
    bool sendPacket(Packet<uint8_t>* p);
 
    void sendPackets();
 
    void sendStartSequencePackets(uint16_t destination, uint8_t seq_id, uint16_t num_packets);
 
 
    QueuePacket<ControlPacket>* getStartSequencePacketQueue(uint16_t destination, uint8_t seq_id, uint16_t num_packets);
 
    void sendAckPacket(uint16_t destination, uint8_t seq_id, uint16_t seq_num);
 
    void sendLostPacket(uint16_t destination, uint8_t seq_id, uint16_t seq_num);
 
    void printHeaderPacket(Packet<uint8_t>* p, String title);
 
    bool processLargePayloadPacket(QueuePacket<ControlPacket>* pq);
 
    void processSyncPacket(uint16_t source, uint8_t seq_id, uint16_t seq_num);
 
    void addAck(uint16_t source, uint8_t seq_id, uint16_t seq_num);
 
    uint8_t sequence_id = 0;
 
    uint8_t getSequenceId();
 
    void managerSendQueue();
 
    void managerReceivedQueue();
 
    struct sequencePacketConfig {
        //Identification is Sequence Id and Source address
        uint8_t seq_id; //Sequence Id
        uint16_t source; //Source Address
 
        uint16_t number{0}; //Number of packets of the sequence
        uint8_t firstAckReceived{0}; //If this value is set to 0, there has not been received any ack.
        uint16_t lastAck{0}; //Last ack received/send. 0 to n ACKs where n is the number of packets. 
        unsigned long timeout{0};; //Timeout of the sequence
        uint8_t numberOfTimeouts{0}; //Number of timeouts that has been occurred
        uint32_t RTT{0}; //Round Trip time
 
        sequencePacketConfig(uint8_t seq_id, uint16_t source, uint16_t number) : seq_id(seq_id), source(source), number(number) {};
    };
 
    struct listConfiguration {
        sequencePacketConfig* config;
        LM_LinkedList<QueuePacket<ControlPacket>>* list;
    };
 
    void actualizeRTT(listConfiguration* config);
 
    void processLostPacket(uint16_t destination, uint8_t seq_id, uint16_t seq_num);
 
    bool sendPacketSequence(listConfiguration* lstConfig, uint16_t seq_num);
 
    void joinPacketsAndNotifyUser(listConfiguration* listConfig);
 
    void addTimeout(LM_LinkedList<listConfiguration>* queue, uint8_t seq_id, uint16_t source);
 
    void resetTimeout(sequencePacketConfig* configPacket);
 
    void addTimeout(sequencePacketConfig* configPacket);
 
    void clearLinkedList(listConfiguration* listConfig);
 
    void findAndClearLinkedList(LM_LinkedList<listConfiguration>* queue, listConfiguration* listConfig);
 
    listConfiguration* findSequenceList(LM_LinkedList<listConfiguration>* queue, uint8_t seq_id, uint16_t source);
 
    LM_LinkedList<listConfiguration>* q_WSP = new LM_LinkedList<listConfiguration>();
 
    LM_LinkedList<listConfiguration>* q_WRP = new LM_LinkedList<listConfiguration>();
 
    uint32_t maxTimeOnAir = 0;
 
    uint8_t preambleReceivedWhenSending = 0;
 
    void waitBeforeSend(uint8_t repeatedDetectPreambles);
 
    void recalculateMaxTimeOnAir();
 
};
 
#endif