1

/*

     2

    Copyright Edouard TISSERANT 2024

     3

    See COPYING for details

     4

*/

     5

     6

#if !defined(_PLCObject_hpp_)

     7

#define _PLCObject_hpp_

     8

     9

#include <map>

    10

#include <vector>

    11

#include <mutex>

    12

#include <thread>

    13

    14

#include "blob.hpp"

    15

    16

#include "erpc_PLCObject_interface.hpp"

    17

    18

using namespace erpcShim;

    19

    20

#define FOR_EACH_PLC_SYMBOLS_DO(ACTION) \

    21

    ACTION(PLC_ID)\

    22

    ACTION(startPLC)\

    23

    ACTION(stopPLC)\

    24

    ACTION(ResetDebugVariables)\

    25

    ACTION(RegisterDebugVariable)\

    26

    ACTION(FreeDebugData)\

    27

    ACTION(GetDebugData)\

    28

    ACTION(suspendDebug)\

    29

    ACTION(resumeDebug)\

    30

    ACTION(ResetLogCount)\

    31

    ACTION(GetLogCount)\

    32

    ACTION(LogMessage)\

    33

    ACTION(GetLogMessage)

    34

    35

extern "C" {   

    36

    typedef struct s_PLCSyms{

    37

        uint8_t *PLC_ID;

    38

        int (*startPLC)(int argc,char **argv);

    39

        int (*stopPLC)(void);

    40

        void (*ResetDebugVariables)(void);

    41

        int (*RegisterDebugVariable)(unsigned int idx, void* force, size_t force_size);

    42

        void (*FreeDebugData)(void);

    43

        int (*GetDebugData)(unsigned int *tick, unsigned int *size, void **buffer);

    44

        int (*suspendDebug)(int disable);

    45

        void (*resumeDebug)(void);

    46

        void (*ResetLogCount)(void);

    47

        uint32_t (*GetLogCount)(uint8_t level);

    48

        int (*LogMessage)(uint8_t level, char* buf, uint32_t size);

    49

        uint32_t (*GetLogMessage)(uint8_t level, uint32_t msgidx, char* buf, uint32_t max_size, uint32_t* tick, uint32_t* tv_sec, uint32_t* tv_nsec);

    50

    } PLCSyms;

    51

}

    52

class PLCObject : public BeremizPLCObjectService_interface

    53

{

    54

    public:

    55

    56

        PLCObject(void);

    57

        ~PLCObject(void);

    58

    59

        // ERPC interface

    60

        uint32_t AppendChunkToBlob(const binary_t * data, const binary_t * blobID, binary_t * newBlobID);

    61

        uint32_t GetLogMessage(uint8_t level, uint32_t msgID, log_message * message);

    62

        uint32_t GetPLCID(PSKID * plcID);

    63

        uint32_t GetPLCstatus(PLCstatus * status);

    64

        uint32_t GetTraceVariables(uint32_t debugToken, TraceVariables * traces);

    65

        uint32_t MatchMD5(const char * MD5, bool * match);

    66

        uint32_t NewPLC(const char * md5sum, const binary_t * plcObjectBlobID, const list_extra_file_1_t * extrafiles, bool * success);

    67

        uint32_t PurgeBlobs(void);

    68

        uint32_t RepairPLC(void);

    69

        uint32_t ResetLogCount(void);

    70

        uint32_t SeedBlob(const binary_t * seed, binary_t * blobID);

    71

        uint32_t SetTraceVariablesList(const list_trace_order_1_t * orders, int32_t * debugtoken);

    72

        uint32_t StartPLC(void);

    73

        uint32_t StopPLC(bool * success);

    74

        uint32_t ExtendedCall(const char * method, const binary_t * argument, binary_t * answer);

    75

    76

        // Public interface used by runtime

    77

        uint32_t AutoLoad();

    78

        uint32_t LogMessage(uint8_t level, std::string message);

    79

    80

    private:

    81

        // A map of all the blobs

    82

        std::map<std::vector<uint8_t>, Blob*> m_mapBlobIDToBlob;

    83

    84

        // PLC object library handle

    85

        void * m_handle;

    86

    87

        // Shared object mutex

    88

        std::mutex m_PLClibMutex;

    89

    90

        // Symbols resolved from the PLC object

    91

        PLCSyms m_PLCSyms;

    92

    93

        // argc and argv for the PLC object

    94

        int m_argc;

    95

        char ** m_argv;

    96

    97

        // PLC status

    98

        PLCstatus m_status;

    99

   100

        // PSK

   101

        std::string m_PSK_ID;

   102

        std::string m_PSK_secret;

   103

   104

        // Debug token, used for consistency check of traces

   105

        uint32_t m_debugToken;

   106

   107

        // Trace thread

   108

        std::thread m_traceThread;

   109

   110

        // Trace thread mutex

   111

        std::mutex m_tracesMutex;

   112

   113

        // Trace double buffer

   114

        std::vector<trace_sample> m_traces;

   115

   116

        uint32_t BlobAsFile(const binary_t * BlobID, std::filesystem::path filename);

   117

        uint32_t LoadPLC(void);

   118

        uint32_t UnLoadPLC(void);

   119

        uint32_t PurgePLC(void);

   120

        void PurgeTraceBuffer(void);

   121

        void TraceThreadProc(void);

   122

};

   123

   124

#endif