meshPacket.h

Go to the documentation of this file.

 
#ifndef MESH_PACKET_H
#define MESH_PACKET_H
 
#include "meshFrame.h"
 
//SystemPacketTypes from 0 to 4 can be sent between networks.
typedef enum: uint8_t {
    SPT_ACK = 0,            
    SPT_ERR_ACK = 1,        
    SPT_NetScan = 2,        
    SPT_Connect = 3,        
    SPT_Reserved = 4,       
    SPT_Disconnect = 7,     
    SPT_NeighborScan = 8,   
    SPT_PathDiscovery = 9,  
    SPT_Ping = 10,          
    SPT_DATA = 254,
    SPT_ERROR = 255
}SystemPacketType;
 
struct MeshPacketHeader {
    MeshPacketHeader() = default;
 
    MeshFrameControl FrameControl;
 
    uint8_t ID = 0;
 
    inline uint16_t GetUniquePacketID() const {
        return (uint16_t)ID << 8 | Source;
    }
 
    uint8_t Source = INVALID_MESH_ADDRESS;
 
    uint8_t Destination = INVALID_MESH_ADDRESS;
 
    uint8_t From = INVALID_MESH_ADDRESS;
 
    uint8_t To = INVALID_MESH_ADDRESS;
 
    uint8_t Hops = 0;
 
    inline bool HasError() const {
        return !IS_VALID_MESH_SRC_ADDRESS(Source)
            || (FrameControl.ContainsDestinationAddress() && !IS_VALID_MESH_DEST_ADDRESS(Destination))
            || (FrameControl.ContainsFromAddress() && !IS_VALID_MESH_FROM_ADDRESS(From))
            || (FrameControl.ContainsToAddress() && !IS_VALID_MESH_TO_ADDRESS(To));
    }
 
    void Clear();
 
    void operator=(const MeshFrameHeader& val) {
        FrameControl = val.FrameControl;
        ID = val.ID;
        Source = val.Source;
    }
 
    inline uint16_t GetRawLength(bool includeCarriageCount) const {
        return 7 + includeCarriageCount + FrameControl.ContainsDestinationAddress() + FrameControl.ContainsFromAddress() + FrameControl.ContainsToAddress() + FrameControl.ContainsHopCount();
    }
 
    bool FromMeshFrame(const MeshFrame& frame);
 
    bool FromMeshFrame(MeshFrameHeader frameHeader, const uint8_t* data, uint16_t dataSize);
 
    MeshFrameHeader ToMeshFrameHeader(MeshMAC BSSID);
};
 
 
class MeshPacket: public RawPrintable {
public:
 
    MeshPacket();
 
    MeshPacket(const MeshPacket& mp);
 
    MeshPacket(MeshPacket&& mp) noexcept;
 
    ~MeshPacket();
 
    MeshPacket& operator=(const MeshPacket& mp);
 
    MeshPacket& operator=(MeshPacket&& mp) noexcept;
 
    MeshPacketHeader PacketHeader;
 
    inline uint16_t Length() const{
        return PayloadLength;
    }
 
    uint8_t operator [](uint16_t i) const{
        return Payload[i];
    }
 
    uint8_t& operator [](uint16_t i) {
        return Payload[i];
    }
 
    SystemPacketType GetSystemPacketType() const;
 
    uint8_t GetPayloadByteAt(uint16_t index) const;
 
    virtual bool SetPayloadByteAt(uint16_t index, uint8_t value);
 
    virtual bool SetPayload(const uint8_t* payload, const uint16_t payloadLength);
 
    inline bool SetPayload(const MeshVariableArray<uint8_t>& va) {
        return SetPayload(va.d_ptr(), va.Length());
    }
 
    virtual bool SetPayload(MeshVariableArray<uint8_t>&& va);
 
    void GetPayload(uint8_t* payload, uint16_t& payloadLength) const;
 
    inline bool GetPayload(MeshVariableArray<uint8_t>& payload) const {
        return payload.SetArray(Payload, PayloadLength);
    }
 
    MeshVariableArray<uint8_t> TakePayload();
 
    bool ResizePayload(uint16_t size, bool doNotCopy = false);
 
    void ClearPayload();
 
    virtual void Clear();
 
    virtual bool copyFrom(const MeshPacket& another);
 
    virtual void moveFrom(MeshPacket& another);
 
    inline const uint8_t* p_ptr() const{
        return Payload;
    }
 
    size_t prettyPrint(OSTREAM& stream) const;
 
    size_t printTo(Print& p) const override;
 
    size_t printHeader(OSTREAM* stream) const override;
 
    size_t printLine(OSTREAM* stream) const override;
 
    inline size_t sizeOf() const override {
        return sizeof(*this) + Length();
    }
 
    size_t printRaw(OSTREAM* stream, void(*CRC_calculation)(uint8_t*, size_t)) const override;
 
    virtual size_t getRawSize() const override;
 
    virtual inline bool HasError() const{
        return error || PacketHeader.HasError();
    }
 
    inline void SetError() {
        error = true;
    }
 
    inline bool GetError() const {
        return error;
    }
 
    inline void ClearError() {
        error = false;
    }
    
protected:
 
    uint8_t* Payload = NULL;
 
    uint16_t PayloadLength : 10;
 
    bool error : 1;
 
    static inline char toHEXChar(OSTREAM& stream, uint8_t val) {
        uint8_t raw = val & 0x0F;
        if (raw < 10) return '0' + raw;
        else return 'A' + raw - 10;
    }
 
    static size_t printHex(OSTREAM& stream, uint8_t val);
};
 
#endif // !MESH_PACKET_H