meshPacketFlags.h

Go to the documentation of this file.

 
#ifndef MESH_PACKET_FLAGS_H
#define MESH_PACKET_FLAGS_H
 
#include "meshHelper.h"
 
struct MeshFrameControl {
    //Do not reorder
public:
    MeshFrameControl() :
        RoutingEnabled(false),
        RelayingEnabled(false),
        SystemPacket(false),
        CarriageHeader(false),
        CarriageFrame(false),
        SecuredPacket(false),
        ACKRequired(false),
        MoreFrameControl(false)
    {}
 
    MeshFrameControl(uint8_t raw) {
        operator=(raw);
    }
 
    MeshFrameControl(const MeshFrameControl&) = default;
    MeshFrameControl& operator=(const MeshFrameControl&) = default;
 
    volatile bool RoutingEnabled : 1;
 
    volatile bool RelayingEnabled : 1;
 
    volatile bool SystemPacket : 1;
 
 
    inline void SetCarriageFrame(bool isCarriageFrame, bool isHeader = false) {
        CarriageFrame = isCarriageFrame;
        CarriageHeader = (isCarriageFrame && isHeader);
    }
 
    inline bool IsCarriageFrame() const {
        return CarriageFrame;
    }
 
    inline bool IsCarriageHeader() const {
        return CarriageFrame && CarriageHeader;
    }
 
 
private:
 
    volatile bool CarriageHeader : 1;
 
    volatile bool CarriageFrame : 1;
 
public:
    volatile bool SecuredPacket : 1;
 
    volatile bool ACKRequired : 1;
 
    volatile bool MoreFrameControl : 1;
 
    inline bool ContainsDestinationAddress() const {
        return RelayingEnabled || RoutingEnabled;
    }
 
    inline bool ContainsHopCount() const {
        return RelayingEnabled;
    }
 
    inline bool ContainsFromAddress() const {
        return RelayingEnabled;
    }
 
    inline bool ContainsToAddress() const {
        return RelayingEnabled && RoutingEnabled;
    }
 
    inline void Clear() {
        *((uint8_t*)this) = (uint8_t)0;
    }
 
    //Operators, that allows converting struct to uint8_t and opposite
    MeshFrameControl& operator=(uint8_t val) {
        *((uint8_t*)this) = val;
        return *this;
    }
 
    operator uint8_t() const { return *((uint8_t*)this); }
    operator uint8_t() { return *((uint8_t*)this); }
 
    size_t prettyPrint(OSTREAM& stream) const;
};
 
 
 
 
 
struct MeshNetScanFlags {
    //Do not reorder
public:
    MeshNetScanFlags() :
        RespondConnected(true),
        RespondDisconnected(true),
        RespondMainGatewayNode(true),
        RespondBackupGatewayNode(true), //Reserved for future use
        CanRespondSameNetNode(false),
        Reserved1_6(false),
        Reserved1_7(false),
        Reserved1_8(false),
 
        SendSSID(false),
        ResponderIsMAC(false),
        IgnoreRSSIThreshold(false),
        Reserved2_4(false),
        Reserved2_5(false),
        Reserved2_6(false),
        Reserved2_7(false),
        Reserved2_8(false)
    {}
 
    MeshNetScanFlags(uint16_t raw) {
        operator=(raw);
    }
 
    MeshNetScanFlags(const MeshNetScanFlags&) = default;
    MeshNetScanFlags& operator=(const MeshNetScanFlags&) = default;
 
    volatile bool RespondConnected : 1;
 
    volatile bool RespondDisconnected : 1;
 
    volatile bool RespondMainGatewayNode : 1;
 
    volatile bool RespondBackupGatewayNode : 1;
 
    volatile bool CanRespondSameNetNode : 1;
 
 
 
    volatile bool Reserved1_6 : 1;
    volatile bool Reserved1_7 : 1;
    volatile bool Reserved1_8 : 1;
 
    volatile bool SendSSID : 1;
 
    volatile bool ResponderIsMAC : 1;
 
    volatile bool IgnoreRSSIThreshold : 1;
 
    volatile bool Reserved2_4 : 1;
    volatile bool Reserved2_5 : 1;
    volatile bool Reserved2_6 : 1;
    volatile bool Reserved2_7 : 1;
    volatile bool Reserved2_8 : 1;
 
    inline void Clear() {
        operator=(0);
    }
 
    //Operators, that allows converting struct to uint16_t and opposite
    MeshNetScanFlags & operator=(uint16_t val) {
        memcpy(this, &val, sizeof(uint16_t));
        return *this;
    }
 
    operator uint16_t() const { return *((uint16_t*)this); }
    operator uint16_t() { return *((uint16_t*)this); }
 
};
 
 
struct MeshNodeDescFlags {
    //Do not reorder
public:
    //TODO
    MeshNodeDescFlags() :
        Reserved1_1(false),
        Reserved1_2(false),
        Reserved1_3(false),
        Reserved1_4(false),
        Reserved1_5(false),
        Reserved1_6(false),
        Reserved1_7(false),
        Reserved1_8(false),
 
        Reserved2_1(false),
        Reserved2_2(false),
        Reserved2_3(false),
        Reserved2_4(false),
        Reserved2_5(false),
        Reserved2_6(false),
        Reserved2_7(false),
        Reserved2_8(false)
    {}
 
    MeshNodeDescFlags(uint16_t raw) {
        operator=(raw);
    }
 
    MeshNodeDescFlags(const MeshNodeDescFlags&) = default;
    MeshNodeDescFlags& operator=(const MeshNodeDescFlags&) = default;
 
    volatile bool Reserved1_1 : 1;
    volatile bool Reserved1_2 : 1;
    volatile bool Reserved1_3 : 1;
    volatile bool Reserved1_4 : 1;
    volatile bool Reserved1_5 : 1;
    volatile bool Reserved1_6 : 1;
    volatile bool Reserved1_7 : 1;
    volatile bool Reserved1_8 : 1;
 
    volatile bool Reserved2_1 : 1;
    volatile bool Reserved2_2 : 1;
    volatile bool Reserved2_3 : 1;
    volatile bool Reserved2_4 : 1;
    volatile bool Reserved2_5 : 1;
    volatile bool Reserved2_6 : 1;
    volatile bool Reserved2_7 : 1;
    volatile bool Reserved2_8 : 1;
 
    inline void Clear() {
        operator=(0);
    }
 
    //Operators, that allows converting struct to uint16_t and opposite
    MeshNodeDescFlags& operator=(uint16_t val) {
        memcpy(this, &val, sizeof(uint16_t));
        return *this;
    }
 
    operator uint16_t() const { return *((uint16_t*)this); }
    operator uint16_t() { return *((uint16_t*)this); }
 
};
 
 
struct MeshPingFlags {
    //Do not reorder
public:
    MeshPingFlags() :
        IsResponse(false),
        Reserved1_2(false),
        Reserved1_3(false),
        Reserved1_4(false),
        Reserved1_5(false),
        Reserved1_6(false),
        Reserved1_7(false),
        Reserved1_8(false),
 
        Reserved2_1(false),
        Reserved2_2(false),
        Reserved2_3(false),
        Reserved2_4(false),
        Reserved2_5(false),
        Reserved2_6(false),
        Reserved2_7(false),
        Reserved2_8(false)
    {}
 
    MeshPingFlags(uint16_t raw) {
        operator=(raw);
    }
 
    MeshPingFlags(const MeshPingFlags&) = default;
    MeshPingFlags& operator=(const MeshPingFlags&) = default;
 
    volatile bool IsResponse : 1;
 
    volatile bool Reserved1_2 : 1;
    volatile bool Reserved1_3 : 1;
    volatile bool Reserved1_4 : 1;
    volatile bool Reserved1_5 : 1;
    volatile bool Reserved1_6 : 1;
    volatile bool Reserved1_7 : 1;
    volatile bool Reserved1_8 : 1;
 
    volatile bool Reserved2_1 : 1;
    volatile bool Reserved2_2 : 1;
    volatile bool Reserved2_3 : 1;
    volatile bool Reserved2_4 : 1;
    volatile bool Reserved2_5 : 1;
    volatile bool Reserved2_6 : 1;
    volatile bool Reserved2_7 : 1;
    volatile bool Reserved2_8 : 1;
 
    inline void Clear() {
        operator=(0);
    }
 
    //Operators, that allows converting struct to uint16_t and opposite
    MeshPingFlags& operator=(uint16_t val) {
        memcpy(this, &val, sizeof(uint16_t));
        return *this;
    }
 
    operator uint16_t() const { return *((uint16_t*)this); }
    operator uint16_t() { return *((uint16_t*)this); }
 
};
 
 
struct MeshNetScanResult {
    MeshMAC BSSID;
    uint8_t Address = 0;
    MeshVersion Version;
    MeshNodeDescFlags Flags;
    uint8_t HopsToGateway = 0;
    char* SSID_ptr = NULL;
    uint8_t SSID_length = 0;
 
    int8_t RSSI = 0;
 
    inline bool IsValid() const {
        return IS_VALID_MESH_ADDRESS(Address) || Address == UNKNOWN_MESH_ADDRESS;
    }
 
    inline bool IsGateway() const {
        return Address != 0;
    }
 
    inline bool IsConneted() const {
        return Address != UNKNOWN_MESH_ADDRESS;
    }
};
 
#endif // !MESH_PACKET_FLAGS_H