core/redAcore
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Important Update;

Browse Source 
- ApplicationCore:
  - Minor log updates
- FunctionCore:
  - Initialise structs & object params in declaration
- DeviceCore:
  - Update logs with more consistent structure
  - Initialise structs & object params in declaration
  - Implemented DeviceType templates
    - Added Add/Get/Destroy methods
    - Load from config or separate template file
    - Build Devices/Params from template
  - Implemented ParamGroups
    - Added Add/Get/Destroy methods
    - Load with DeviceTypes
  - Added JSON parser to read separate template files
  - Bug fix: Getxxxx() methods
This commit is contained in:
Charl Wentzel
2018-12-13 09:17:39 +02:00
parent 90beb031af
commit dc76d99b58
5 changed files with 565 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
DeviceCore.h
View File

@@ -12,6 +12,7 @@
/* none */
// redA Libraries
#include "JSONparseCore.h"
#include "FunctionCore.h"
//---------------------------------------------------------------------------
@@ -26,50 +27,67 @@ const char DataTypeName[][20] = { "None", "Unsigned16", "Signed16", "Unsigned32"
//---------------------------------------------------------------------------
// Structure prototypes
typedef struct SDevice TDevice;
typedef struct SDeviceParam TDeviceParam;
typedef struct SDevice TDevice;
typedef struct SDeviceParam TDeviceParam;
typedef struct SDeviceParamGroup TDeviceParamGroup;
typedef struct SDeviceParamItem TDeviceParamItem;
// Devices with are polled
struct SDevice {
// Device definition
char * Name;
char * Type;
char * Name = NULL;
char * Type = NULL;
TDevice * Template = NULL;
// Device status
bool Online;
bool Online = false;
// Device parameters
TDeviceParam * FirstParam;
TDeviceParam * FirstParam = NULL;
// Device peer list
TDevice * Next;
TDevice * Next = NULL;
};
// Data parameters of devices
struct SDeviceParam {
// Parameter definition
char * Name;
EDeviceDataType DataType;
char * Name = NULL;
EDeviceDataType DataType = dtNone;
TDevice * Device = Device;
// Last value (received from device)
void * Value = NULL;
int Len = 0;
bool Changed = false;
// Polling/Event parameters
bool Read;
TChannel * EventChannel;
long EventInterval;
bool Read = false;
TChannel * EventChannel = NULL;
long EventInterval = 0;
timeval EventTimeout;
// Last value received from device
void * Value;
int Len;
bool Changed;
// Value to on device
bool Write;
void * SetValue;
int SetLen;
bool SetChanged;
bool Write = false;
void * SetValue = NULL;
int SetLen = 0;
bool SetChanged = false;
// Parameter peer list
TDeviceParam * Next;
TDeviceParam * Next = NULL;
};
// Parameters groups - used where parameters are read/written as a groug
struct SDeviceParamGroup {
char * Name = NULL;
TDevice * Device = NULL;
TDeviceParamItem * FirstParam = NULL;
TDeviceParamGroup * NextGroup = NULL;
};
struct SDeviceParamItem {
TDeviceParam * Param = NULL;
TDeviceParamItem * NextItem = NULL;
};
//---------------------------------------------------------------------------
@@ -84,17 +102,22 @@ class CDeviceCore : public CFunctionCore
{
protected:
// Configuration
CDataMember * Config;
bool DeviceInit;
CDataMember * Config = NULL;
CDataMember * ConfigTypes = NULL;
CJSONparse * JSONparse = NULL;
bool DeviceInit = false;
// Parameters
TDevice * FirstDevice;
TDevice * ActiveDevice;
// Devices & Type
TDevice * FirstDeviceType = NULL;
TDevice * FirstDevice = NULL;
TDevice * ActiveDevice = NULL;
TDeviceParamGroup * FirstParamGroup = NULL;
// Standard channels
TChannel * DeviceChannel;
TChannel * CmdChannel;
TChannel * EventChannel;
TChannel * DeviceChannel = NULL;
TChannel * CmdChannel = NULL;
TChannel * EventChannel = NULL;
// Poll
int PollStep; // Position in polling sequence
@@ -112,27 +135,39 @@ protected:
// Manage Devices
bool DestroyDevice( TDevice ** Device );
// Find Device Types
inline TDevice * GetDeviceType( const char * TypeName ) {
TDevice ** DeviceType = GetDeviceTypePtr( TypeName );
return (DeviceType)? *DeviceType : NULL;
}
inline TDevice ** GetDeviceTypePtr( const char * TypeName ) {
if (!TypeName || !*TypeName) return NULL;
TDevice ** DeviceType = &FirstDeviceType;
while (*DeviceType && strcasecmp( (*DeviceType)->Type, TypeName ))
DeviceType = &((*DeviceType)->Next);
return DeviceType;
}
// Find Devices
inline TDevice * GetDevice( const char * Name ) {
TDevice * Device = FirstDevice;
while (Device && strcasecmp( Device->Name, Name ))
Device = Device->Next;
return Device;
TDevice ** Device = GetDevicePtr(Name);
return (Device)? *Device : NULL;
}
inline TDevice ** GetDevicePtr( const char * Name ) {
TDevice ** Device = &FirstDevice;
if (!Name || !*Name) return NULL;
TDevice ** Device = &FirstDevice;
while (*Device && strcasecmp( (*Device)->Name, Name ))
Device = &((*Device)->Next);
return Device;
}
inline TDevice * GetNextTypeDevice( const char * Type, TDevice * PrevDevice = NULL ) {
TDevice * Device = (PrevDevice)? PrevDevice->Next : FirstDevice;
while (Device && ((!Type && Device->Type) || (Type && (!Device->Type || !strcasecmp( Type, Device->Type )))))
TDevice * Device = (PrevDevice)? PrevDevice->Next : FirstDevice;
while (Device && ((!Type && Device->Type) || (Type && (!Device->Type || strcasecmp( Type, Device->Type )))))
Device = Device->Next;
return Device;
}
inline TDevice * GetNextOnlineDevice( TDevice * PrevDevice = NULL ) {
TDevice * Device = (PrevDevice)? PrevDevice->Next : FirstDevice;
TDevice * Device = (PrevDevice)? PrevDevice->Next : FirstDevice;
while (Device && !Device->Online)
Device = Device->Next;
return Device;
@@ -143,41 +178,68 @@ protected:
// Find Params
inline TDeviceParam * GetDeviceParam( TDevice * Device, const char * pName ) {
if (!Device || !pName) return NULL;
TDeviceParam * Param = Device->FirstParam;
while (Param && strcasecmp( Param->Name, pName ))
Param = Param->Next;
return Param;
TDeviceParam ** Param = GetDeviceParamPtr(Device, pName);
return (Param)? *Param : NULL;
}
inline TDeviceParam ** GetDeviceParamPtr( TDevice * Device, const char * pName ) {
if (!Device || !pName) return NULL;
TDeviceParam ** Param = &(Device->FirstParam);
if (!Device || !pName || !*pName) return NULL;
TDeviceParam ** Param = &(Device->FirstParam);
while (*Param && strcasecmp( (*Param)->Name, pName ))
Param = &((*Param)->Next);
return Param;
}
inline TDeviceParam * GetNextReadParam( TDevice * Device, TDeviceParam * LastParam = NULL ) {
if (!Device) return NULL;
TDeviceParam * Param = (LastParam)? LastParam->Next : Device->FirstParam;
TDeviceParam * Param = (LastParam)? LastParam->Next : Device->FirstParam;
while (Param && (!Param->Read))
Param = Param->Next;
return Param;
}
inline TDeviceParam * GetNextChangedParam( TDevice * Device, TDeviceParam * LastParam = NULL ) {
if (!Device) return NULL;
TDeviceParam * Param = (LastParam)? LastParam->Next : Device->FirstParam;
TDeviceParam * Param = (LastParam)? LastParam->Next : Device->FirstParam;
while (Param && (!Param->Changed))
Param = Param->Next;
return Param;
}
inline TDeviceParam * GetNextSetChangedParam( TDevice * Device, TDeviceParam * LastParam = NULL ) {
if (!Device) return NULL;
TDeviceParam * Param = (LastParam)? LastParam->Next : Device->FirstParam;
TDeviceParam * Param = (LastParam)? LastParam->Next : Device->FirstParam;
while (Param && (!Param->SetChanged))
Param = Param->Next;
return Param;
}
// Manage Param Groups
bool DestroyParamGroup( TDeviceParamGroup ** Group );
bool DestroyParamItem( TDeviceParamItem ** Item );
// Find Param Groups
inline TDeviceParamGroup * GetParamGroup( const char * GroupName ) {
TDeviceParamGroup ** Group = GetParamGroupPtr( GroupName );
return (Group)? *Group : NULL;
}
inline TDeviceParamGroup ** GetParamGroupPtr( const char * GroupName ) {
if (!GroupName || !*GroupName) return NULL;
TDeviceParamGroup ** Group = &FirstParamGroup;
while (*Group && strcasecmp( (*Group)->Name, GroupName ))
Group = &((*Group)->NextGroup);
return Group;
}
// Find Param Groups Items
inline TDeviceParamItem * GetParamItem( TDeviceParamGroup * Group, const char * ParamName ) {
TDeviceParamItem ** Item = GetParamItemPtr( Group, ParamName );
return (Item)? *Item : NULL;
}
inline TDeviceParamItem ** GetParamItemPtr( TDeviceParamGroup * Group, const char * ParamName ) {
if (!Group || !ParamName || !*ParamName) return NULL;
TDeviceParamItem ** Item = &Group->FirstParam;
while (*Item && strcasecmp( (*Item)->Param->Name, ParamName ))
Item = &((*Item)->NextItem);
return Item;
}
// Tools
inline EDeviceDataType GetDataType( const char * TypeName ) {
int Type;
@@ -207,6 +269,8 @@ public:
// Configuration
virtual bool Init( CDataMember * FunctionConfig );
virtual bool InitDevices( CDataMember * FunctionConfig );
virtual bool InitDeviceParams( TDevice * Device, CDataMember * DeviceConfig );
virtual bool InitParamGroups( TDevice * Device, CDataMember * DeviceConfig );
// Polling parameters
bool SetPollParam( int pPollInterval );
@@ -215,6 +279,13 @@ public:
bool SetParamAccess( TDeviceParam * Param, bool Read, bool Write );
bool SetParamEvent( TDeviceParam * Param, const char * ChannelName, long pEventInterval );
// Manage Devices Types
TDevice * AddDeviceType( const char * DeviceTypeName );
inline bool DestroyDeviceType( const char * DeviceTypeName ) {
TDevice ** DeviceType = GetDeviceTypePtr(DeviceTypeName);
return (DeviceType)? DestroyDevice( DeviceType ) : false;
}
// Manage Devices
TDevice * AddDevice( const char * DeviceName, const char * Type = NULL );
inline bool DestroyDevice( const char * DeviceName ) {
@@ -229,6 +300,18 @@ public:
return (Param)? DestroyDeviceParam( Param ) : false;
};
// Manage Param Groups
TDeviceParamGroup * AddParamGroup( TDevice * Device, const char * GroupName );
inline bool DestroyParamGroup( const char * GroupName ) {
TDeviceParamGroup ** Group = GetParamGroupPtr( GroupName );
return (Group)? DestroyParamGroup( Group ) : false;
};
TDeviceParamItem * AddParamItem( TDeviceParamGroup * Group, const char * ParamName );
inline bool DestroyParamItem( TDeviceParamGroup * Group, const char * ParamName ) {
TDeviceParamItem ** Item = GetParamItemPtr( Group, ParamName );
return (Item)? DestroyParamItem( Item ) : false;
};
// Update/Init Param values
bool UpdateUnsignedValue( TDeviceParam * Param, const u_int32_t Value, bool Init );
bool UpdateSignedValue( TDeviceParam * Param, const int32_t Value, bool Init );