meshPacketBuilder.h

Go to the documentation of this file.

 
#ifndef MESH_PACKET_BUILDER_H
#define MESH_PACKET_BUILDER_H
 
#include "meshPacket.h"
 
typedef enum : int8_t {
    MPB_None = 0,
 
//OK status:
    MPB_FullPacketOK = 1,
    MPB_PartPacketOK = 2,
    MPB_Ignored = 3,
 
//WARNING status:
    MPB_SameFrameReceived = -1,
 
//ERROR status:
    MPB_InvalidFrameError = -2,
    MPB_FrameSizeExceededError = -3,
    MPB_FrameOrderError = -4,
    MPB_FrameHeaderMissingError = -5,
    MPB_InvalidPacketError = -6,
 
//FATAL ERROR status:
    MPB_PayloadSizeExceededError = -7,
    MPB_AllocationError = -8,
 
//INTEGRITY ERROR status :
    MPB_PacketIntegrityError = -9
 
}MeshPacketBuilderStatus;
 
#ifdef SIMULATION
class MeshNet;
#endif
 
class MeshPacketBuilder {
public:
    MeshPacketBuilderStatus Append(const uint8_t* rawData, uint8_t rawDataSize, int8_t rssi);
 
    MeshPacketBuilderStatus Append(MeshFrame& frame, int8_t rssi);
 
    MeshPacketBuilderStatus Append(MeshFrameHeader frameHeader, const uint8_t* data, uint8_t dataSize, int8_t rssi);
 
    void Clear();
 
    void inline SetFrameReceivedCallback(void (*callback)(MeshPacketBuilder*, MeshPacketBuilderStatus, const MeshFrameHeader&, const uint8_t*, uint8_t, int8_t)) {
        FrameRecv_func = callback;
    }
 
    void inline SetPacketCheckCallback(bool (*callback)(MeshPacketBuilder*, const MeshPacketHeader&, MeshMAC, SystemPacketType, const uint8_t*, uint8_t, int8_t)) {
        PacketCheck_func = callback;
    }
 
    void SetMaxFrameSize(uint8_t size);
 
    inline uint8_t GetMaxFrameSize() const {
        return maxFrameSize;
    }
 
    inline uint16_t GetPredictedMinPacketDataLength() const {
        return predictedMinPacketDataLength;
    }
 
    inline uint16_t GetPredictedMaxPacketDataLength() const {
        return predictedMinPacketDataLength - 1 + headerFrameSize;
    }
 
    inline bool IsEmpty() const {
        return lastStatus == MPB_None;
    }
 
    inline MeshPacketBuilderStatus GetStatus() const {
        return lastStatus;
    }
 
    inline bool PacketIsBuilding() const {
        return lastStatus == MPB_PartPacketOK;
    }
 
    inline bool PacketAvailable() const {
        return lastStatus == MPB_FullPacketOK;
    }
 
    inline bool HasError() const {
        return lastStatus < MPB_None;
    }
 
    inline const MeshPacket& GetBuiltPacket() const {
        return LastPacket;
    }
 
    inline MeshPacket& GetBuiltPacket() {
        return LastPacket;
    }
 
    MeshPacket&& TakeBuiltPacket();
 
    inline MeshMAC GetLastPacketBSSID() const {
        return lastBSSID;
    }
 
    inline SystemPacketType GetLastPacketSystemType() const {
        return lastSPT;
    }
 
    inline MeshPacketHeader GetLastPacketHeader() const{
        return LastPacket.PacketHeader;
    }
 
    inline MeshFrameControl GetLastPacketFrameControl() const {
        return LastPacket.PacketHeader.FrameControl;
    }
 
    uint8_t RemainingCarriageFramesCount() const;
 
    uint8_t CarriageFramesCount() const;
 
    inline uint8_t ReceivedFramesCount() const {
        return CarriageFramesCount() - RemainingCarriageFramesCount();
    }
 
    int8_t GetAverageRSSI() const;
 
    inline int8_t GetMinRSSI() const{
        return RSSI_min;
    }
 
    inline uint32_t GetAppendingEndTime() const {
        return lastReceiveTime;
    }
 
#ifdef SIMULATION
    MeshNet* mn = NULL;
#endif
 
protected:
    bool (*PacketCheck_func)(MeshPacketBuilder*, const MeshPacketHeader&, MeshMAC, SystemPacketType, const uint8_t*, uint8_t, int8_t) = NULL;
    void (*FrameRecv_func)(MeshPacketBuilder*, MeshPacketBuilderStatus, const MeshFrameHeader&, const uint8_t*, uint8_t, int8_t) = NULL;
 
    MeshPacketBuilderStatus lastStatus = MPB_None;
 
    uint32_t lastReceiveTime = 0;
 
    uint16_t predictedMinPacketDataLength = 0;
    uint8_t maxFrameSize = 32;
    uint8_t headerFrameSize = 0;
    uint16_t receivedPayloadCount = 0;
    uint8_t remainingCarriages = 0;
    MeshMAC lastBSSID;
    SystemPacketType lastSPT = SPT_ERROR;
    uint8_t carriageCount = 0;
    MeshPacket LastPacket;
 
    int16_t RSSI_sum = 0;
 
    int8_t RSSI_min = 0;
 
    void discardLastPacket();
 
#ifdef SIMULATION
    inline uint32_t millis();
#endif
};
 
 
struct MeshACKSetup {
 
    MeshACKSetup() = default;
 
    MeshACKSetup(const MeshACKSetup&) = default;
 
    MeshACKSetup(const MeshPacketBuilder& builder);
 
    MeshPacketHeader PacketHeader;
 
    SystemPacketType Type = SPT_ERROR;
 
    MeshMAC BSSID;
 
    uint8_t remainingFrames = 0;
};
 
#endif // !MESH_PACKET_BUILDER_H