abi.h

Go to the documentation of this file.

 
#ifndef ABI_H
#define ABI_H
 
#include "datapoint_value.h"
#include "json.h"
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define GC_INTERFACE_NAME_MAX 50
 
enum eGCLogLevel
{
    CRITICAL,
    ERROR,
    WARNING,
    INFO,
    DEBUG,
};
typedef enum eGCLogLevel GCLogLevel;
 
struct sGCPluginInfo
{
    const char* name;
 
    const char* version;
 
    const char* pluginIfcVersion;
 
    uint64_t features;
};
typedef const struct sGCPluginInfo* GCPluginInfo;
 
struct sGCEthernetInterface
{
    char interface[GC_INTERFACE_NAME_MAX];
};
typedef struct sGCEthernetInterface* GCEthernetInterface;
 
typedef enum
{
    GC_STOP_BITS_ONE = 1, 
    GC_STOP_BITS_TWO = 2  
} GCStopBits;
 
typedef enum
{
    GC_PARITY_NONE = 0, 
    GC_PARITY_ODD = 1,  
    GC_PARITY_EVEN = 2  
} GCParity;
 
typedef enum
{
    GC_DATA_BITS_FIVE = 5,  
    GC_DATA_BITS_SIX = 6,   
    GC_DATA_BITS_SEVEN = 7, 
    GC_DATA_BITS_EIGHT = 8  
} GCDataBits;
 
struct sGCSerialInterface
{
    char interface[GC_INTERFACE_NAME_MAX];
 
    uint32_t baud_rate;
 
    GCParity parity;
 
    GCStopBits stop_bits;
 
    GCDataBits data_bits;
};
typedef struct sGCSerialInterface* GCSerialInterface;
 
struct sGCDatapoint
{
    const char* name;
 
    const char* description;
 
    uint64_t id;
 
    const char* unit;
};
typedef const struct sGCDatapoint GCDatapoint;
 
 
typedef void* GCCoreCtx;
 
typedef void* GCInstanceHandle;
 
typedef bool (*tPublishDatapointValue)(GCCoreCtx, GCDatapointValue);
typedef void (*tStoreDatapointValue)(GCCoreCtx, GCDatapointValue);
typedef GCDatapointValue (*tGetLastDatapointValue)(GCCoreCtx, GCDatapointIdentifier);
typedef void (*tSystemLog)(GCCoreCtx, GCLogLevel, const char*);
typedef void (*tAuditLog)(GCCoreCtx, const char*);
typedef bool (*tReleaseDatapointValue)(GCDatapointValue);
typedef bool (*tGetEthernetInterface)(GCCoreCtx, const char* name, GCEthernetInterface out);
typedef bool (*tGetSerialInterface)(GCCoreCtx, const char* name, GCSerialInterface out);
 
struct sPluginConfig
{
    const GCJsonCallbacks pluginJsonConfig;
 
    const GCDatapoint* ownDatapoints;
    const uint64_t ownDatapointsCount;
 
    const GCDatapoint* subscribedDatapoints;
    const uint64_t subscribedDatapointsCount;
};
typedef const struct sPluginConfig GCPluginConfig;
 
struct sGCPluginInterface
{
    tPublishDatapointValue publishDatapointValueCallback;
 
    tStoreDatapointValue storeDatapointValueCallback;
 
    tSystemLog logSystemCallback;
 
    tAuditLog logAuditCallback;
 
    tReleaseDatapointValue releaseDatapointValueCallback;
 
    tGetLastDatapointValue getLastDatapointValueCallback;
 
    tGetEthernetInterface getEthernetInterfaceCallback;
 
    tGetSerialInterface getSerialInterfaceCallback;
 
    const GCPluginConfig config;
 
    const GCCoreCtx ctx;
 
    const GCLogLevel logLevel;
};
typedef const struct sGCPluginInterface* GCPluginInterface;
 
 
extern GCInstanceHandle
gc_plugin_init(GCPluginInterface interface);
 
extern void
gc_plugin_shutdown(GCInstanceHandle instance);
 
extern GCPluginInfo
gc_plugin_get_info();
 
extern bool
gc_plugin_receive_datapoint(GCInstanceHandle instance, const GCDatapointValue dataValue);
 
 
void
gcSystemLog(GCPluginInterface interface, GCLogLevel level, const char* message, ...);
 
 
void
gcAuditLog(GCPluginInterface interface, const char* message, ...);
 
 
void
gcReleaseDatapointValue(GCPluginInterface interface, GCDatapointValue dataValue);
 
 
bool
gcPublishDatapointValue(GCPluginInterface interface, GCDatapointValue dataValue);
 
 
bool
gcGetEthernetInterface(GCPluginInterface interface, const char* name, GCEthernetInterface out);
 
 
bool
gcGetSerialInterface(GCPluginInterface interface, const char* name, GCSerialInterface out);
 
 
void
gcStoreDatapointValue(GCPluginInterface interface, GCDatapointValue dataValue);
 
#ifdef __cplusplus
}
#endif
 
#endif // ABI_H