Emulator_helpers.h

Go to the documentation of this file.

 
#pragma once
 
#include "meshNetGateway.h"
#include "Simulation_interface.h"
#include <deque>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <list>
 
typedef enum {
    TT_RTable = 0,
    TT_IDTable,
    TT_OIDTable,
    TT_FIDTable,
    TT_DHCPTable,
    TT_WaitingFIFO,
    TT_OutFIFO
} TableType;
 
struct NodeConnections {
    NodeConnections() = default;
 
    NodeConnections(MeshMAC node1, MeshMAC node2) {
        Node1 = node1;
        Node2 = node2;
    }
 
    NodeConnections(MeshMAC node1, MeshMAC node2, float rssi, float rssi_tolerance, float quality) {
        Node1 = node1;
        Node2 = node2;
        RSSI = rssi;
        RSSI_tolerance = rssi_tolerance;
        Quality = quality;
    }
 
    MeshMAC Node1 = 0;
 
    MeshMAC Node2 = 0;
 
    float RSSI = 0.00f;
 
    float RSSI_tolerance = 0.00f;
 
    float getRSSI() const;
 
    float Quality = 1.00f;
 
    bool canReceive() const;
};
 
struct NeighborNode {
    
    NeighborNode(NodeSimulator* neighbor, const NodeConnections* link) {
        Neighbor = neighbor;
        Link = link;
    }
 
    NodeSimulator* Neighbor;
    
    const NodeConnections* Link;
};
 
struct NodeSettings {
    /*
    * @brief MAC address of node.
    */
    MeshMAC MACAddress = 0;
 
    /*
    * @brief True when node is gateway
    */
    bool isGateway = false;
 
    /*
    * @brief Network SSID. This can be set only when node is marked as gateway
    */
    std::string SSID = "";
 
    std::chrono::nanoseconds simulationOffset = std::chrono::nanoseconds::zero();
 
    uint32_t MCUFrequency = 16000000UL;
 
    uint32_t preSendCyclesDelay = 50;
 
    std::chrono::nanoseconds preSendDelay = std::chrono::nanoseconds(13000);
 
    uint32_t sendingSpeed = 1000000UL;
 
    uint32_t extraBitsSentCount = 6 * 8; //Preamble 1 byte, dummy address 3 bytes, CRC 2 bytes
 
    uint32_t postSendCyclesDelay = 50;
 
    std::chrono::nanoseconds postSendDelay = std::chrono::nanoseconds(13000);
 
    uint32_t preReceiveCyclesDelay = 10;
 
    std::chrono::nanoseconds preReceiveDelay = std::chrono::nanoseconds(5000);
 
    uint32_t postReceiveCyclesDelay = 10;
 
    std::chrono::nanoseconds postReceiveDelay = std::chrono::nanoseconds(5000);
 
    uint32_t availableCyclesDelay = 10;
 
    std::chrono::nanoseconds availableDelay = std::chrono::nanoseconds(5000);
 
    uint32_t interferenceCheckCyclesDelay = 10;
 
    std::chrono::nanoseconds interferenceCheckDelay = std::chrono::nanoseconds(5000);
 
    uint8_t maxFrameSize = 32;
 
    int InputFiFoSize = 3;
 
    void clear() {
        isGateway = false;
        SSID = "";
        simulationOffset = std::chrono::nanoseconds::zero();
        MCUFrequency = 16000000UL;
        preSendCyclesDelay = 50;
        preSendDelay = std::chrono::nanoseconds(13000);
        sendingSpeed = 1000000UL;
        extraBitsSentCount = 6 * 8;
        postSendCyclesDelay = 50;
        postSendDelay = std::chrono::nanoseconds(13000);
        preReceiveCyclesDelay = 10;
        preReceiveDelay = std::chrono::nanoseconds(5000);
        postReceiveCyclesDelay = 10;
        postReceiveDelay = std::chrono::nanoseconds(5000);
        availableCyclesDelay = 10;
        std::chrono::nanoseconds(5000);
        interferenceCheckCyclesDelay = 10;
        interferenceCheckDelay = std::chrono::nanoseconds(5000);
        maxFrameSize = 32;
        InputFiFoSize = 3;
        MACAddress = 0;
    }
};
 
struct RawMessage {
public:
 
    RawMessage() = default;
 
    RawMessage(uint8_t* message, uint8_t messageLength, std::chrono::nanoseconds _sentTime, std::chrono::nanoseconds _sendingDoneTime);
 
    void Set(uint8_t* message, uint8_t messageLength, std::chrono::nanoseconds _sentTime, std::chrono::nanoseconds _sendingDoneTime);
 
    void Get(uint8_t* message, uint8_t& messageLength) const;
 
    void Clear();
 
    inline std::chrono::nanoseconds SentTime() const{
        return sentTime;
    }
 
    inline std::chrono::nanoseconds ReceiveTime() const {
        return receiveTime;
    }
 
    inline uint32_t Length() const {
        return length;
    }
 
    inline uint64_t GetUniqueIdentifier() const {
        return uniqueIdentifier;
    }
 
    inline bool IsTransacting(std::chrono::nanoseconds currentSimulationTime) const {
        return currentSimulationTime < ReceiveTime() && sentTime >= currentSimulationTime && !(sentTime == std::chrono::nanoseconds::zero() || receiveTime == std::chrono::nanoseconds::zero());
    }
 
    bool IsInterfering(RawMessage& anotherMessage) const;
 
    bool IsInterfered = false;
 
    MeshMAC SenderNodeMACAddress = 0;
 
    static void printFrameCompressed(uint64_t uniqueID, MeshFrame& msg);
 
    std::string ConvertToBase64();
 
protected:
    uint8_t payload[MESH_FRAME_SIZE_LIMIT];
    uint8_t length = 0;
    std::chrono::nanoseconds sentTime = std::chrono::nanoseconds::zero();
    std::chrono::nanoseconds receiveTime = std::chrono::nanoseconds::zero();
 
    uint64_t uniqueIdentifier = 0;
    static uint64_t globalUniqueIdentifier;
};
 
struct RawMessageDescriptor {
 
    RawMessageDescriptor() = default;
 
    RawMessageDescriptor(std::shared_ptr<RawMessage>& msg_ptr) {
        Message = msg_ptr;
    }
 
    bool IsInterfered = false;
 
    float RSSI = 0.00;
 
    bool BadQuality = false;
 
    std::shared_ptr<RawMessage> Message;
};
 
class Emulator;
 
class NodeSimulator {
public:
 
    NodeSimulator(){}
 
    NodeSimulator(Emulator* emulator, int index, MeshMAC nodeMACAddress);
 
    NodeSimulator(Emulator* emulator, int index);
 
    NodeSimulator(const NodeSimulator&) = default;
 
    ~NodeSimulator();
 
    NodeSimulator& operator=(const NodeSimulator&) = default;
 
    std::thread Thread;
    std::mutex Mutex;
 
    std::function<void(void)> Interrupt = NULL;
 
    inline MeshNet* Node() {
        return currentNode;
    }
 
    inline Emulator* getParentPtr() {
        return em;
    }
 
    inline int getIndex() {
        return index;
    }
 
    inline uint64_t getCyclesCount() {
        return numberOfCycles;
    }
 
    void ExecuteCycle();
 
    inline bool BeginSimulation(NodeSettings settings_, std::chrono::nanoseconds simulationTimeOffset = std::chrono::nanoseconds::zero()) {
        settings = settings_;
        return BeginSimulation(simulationTimeOffset);
    }
 
    bool BeginSimulation(std::chrono::nanoseconds simulationTimeOffset = std::chrono::nanoseconds::zero());
 
    void EndSimulation();
 
    void SleepFor(std::chrono::nanoseconds sleepDelay);
 
    inline bool IsSimulationRunning() {
        return IsSimulationEnabled() && !CycleLock;
    }
 
    inline bool IsSimulationEnabled() {
        return simulationStarted;
    }
 
    std::chrono::nanoseconds getSimulationTime();
 
    inline std::chrono::nanoseconds getNodeWorkTime() {
        return getSimulationTime() - simulationOffset;
    }
 
    inline std::chrono::nanoseconds getLastSentTime() {
        return lastSentTime;
    }
 
    inline const std::vector<NeighborNode>& GetNeighborNodes() {
        return neighborNodes;
    }
 
    inline NodeSettings GetSettings() {
        return settings;
    }
 
protected:
 
    //Methods called by Emulator --- BEGIN
 
    bool IsFree(std::chrono::nanoseconds time);
 
    bool IsFreeEx(std::chrono::nanoseconds time);
 
    uint8_t Available();
 
    inline uint16_t GetLastAvailableBytes() {
        return lastAvailableBytes;
    }
 
    bool Receive(uint8_t* message, uint8_t& messageLength, float& RSSI);
 
    void Send(uint8_t* message, uint8_t messageLength);
 
    void OnScanResponse(const MeshNetScanResult& result);
 
    //TODO
    void CreateRandomInterference(std::chrono::microseconds interferingDuration);
 
    void PauseSimulationTimer();
 
    void ResumeSimulationTimer();
 
    //Methods called by Emulator -- END
 
 
    NodeSettings settings;
 
    Emulator* em = NULL;
 
    int index = 0;
 
    uint64_t numberOfCycles = 0;
 
    std::vector<NeighborNode> neighborNodes;
 
    std::chrono::nanoseconds FreeFromTime = std::chrono::nanoseconds::zero();
    std::chrono::nanoseconds FreeSenderFromTime = std::chrono::nanoseconds::zero();
 
    std::deque<RawMessageDescriptor> inputFIFO;
 
    std::list<RawMessageDescriptor> receivedMessagesList;
 
    uint64_t lastCycles = 0;
 
    std::chrono::nanoseconds simulationTime = std::chrono::nanoseconds::zero();
 
    std::chrono::nanoseconds lastSentTime = std::chrono::nanoseconds::zero();
 
    std::chrono::nanoseconds simulationOffset = std::chrono::nanoseconds::zero();
 
    std::atomic<bool> CycleLock{ true };
 
    std::condition_variable_any CycleLockCV;
 
    bool simulationStarted = false;
 
    int lastAvailableBytes = 0;
 
    bool simulationTimerPaused = true;
 
    MeshNet* currentNode = NULL;
 
    Simulation_RFI* currentRFI = NULL;
 
    int CheckForSentMessages();
 
    void ReportInterference(RawMessageDescriptor& msg1, RawMessageDescriptor& msg2, MeshMAC currentNode);
 
    void ReportCollision(RawMessageDescriptor& msg, RawMessage& msg2);
 
    void ReportMessageLost(RawMessageDescriptor& msg, MeshMAC receiverNode);
 
    static void OnNodeConnectedStatic(MeshNet* mesh);
 
    void OnNodeConnected();
 
    static void OnNodeDisconnectedStatic(MeshNet* mesh, MeshDisconnectReason reason, MeshMAC oldBSSID, uint8_t oldAddress);
 
    void OnNodeDisconnected(MeshDisconnectReason reason, MeshMAC oldBSSID, uint8_t oldAddress);
 
    static void OnReceiveStatic(MeshNet* mesh, MeshPacket& packet);
 
    void OnReceive(MeshPacket& packet);
 
    static void OnPingRespStatic(MeshNet* mesh, uint8_t pingID, uint8_t pingAddr, MeshPacketError pingStat, uint8_t hops, uint32_t duration, const uint8_t* testData, int16_t testDataLength);
 
    void OnPingResp(uint8_t pingID, uint8_t pingAddr, MeshPacketError pingStat, uint8_t hops, uint32_t duration, const uint8_t* testData, int16_t testDataLength);
 
 
    friend Emulator; //Friend class
    friend Simulation_RFI; //Friend class
};
 
 
std::string ConvertToBase64(const MeshNetScanResult& result);