#include <uaserver_config.h>
#include <opcua_statuscodes.h>
#include <opcua_attributes.h>
#include <uabase_p_atomic.h>
#include <uaserver_basenode.h>
#include <uaserver_utilities.h>
#if UASERVER_SUPPORT_UNITS
# include <uaserver_units.h>
#endif
#define _USE_MATH_DEFINES
#include <math.h>
#ifndef M_PI
# define M_PI 3.14159265
#endif
#include "uaprovider_demo.h"
#include "uaprovider_demo_helper.h"
#include "uaprovider_demo_identifiers_1.h"
#include "uaprovider_demo_types_1.h"
#include "uaprovider_demo_simulation.h"
#if UASERVER_SUPPORT_EVENTS
# include "uaprovider_demo_events_1.h"
# include "uaprovider_demo_alarmcondition.h"
#endif
#if HAVE_DATA_LOGGER
# include <uabase_settings.h>
# include <uaserver_monitoring.h>
# include <uaserver_datalogger.h>
# if HAVE_DATA_LOGGER_FILE_BACKEND
# include <uaserver_filelogger.h>
# endif
# if HAVE_DATA_LOGGER_SQLITE_BACKEND
# include <uaserver_sqlitelogger.h>
# endif
static OpcUa_Boolean *g_pDataLoggerActive = 0;
#endif
static OpcUa_Timer g_hSimulationTimer = 0;
static OpcUa_UInt32 g_SimulationInterval = 50;
static OpcUa_UInt32 *g_pSimulationSpeed = 0;
static OpcUa_Boolean *g_pSimulationActive = 0;
static OpcUa_Timer g_hAnimationTimer = 0;
static OpcUa_UInt32 g_AnimationInterval = 50;
static OpcUa_Boolean *g_pDynBoolean = 0;
static OpcUa_SByte *g_pDynSByte = 0;
static OpcUa_Byte *g_pDynByte = 0;
static OpcUa_Int16 *g_pDynInt16 = 0;
static OpcUa_UInt16 *g_pDynUInt16 = 0;
static OpcUa_Int32 *g_pDynInt32 = 0;
static OpcUa_UInt32 *g_pDynUInt32 = 0;
static OpcUa_Int64 *g_pDynInt64 = 0;
static OpcUa_UInt64 *g_pDynUInt64 = 0;
static OpcUa_Float *g_pDynFloat = 0;
static OpcUa_Double *g_pDynDouble = 0;
static OpcUa_Double *g_pDynamicValue = 0;
static OpcUa_VariantArrayValue *g_pDynArrayBoolean = 0;
static OpcUa_VariantArrayValue *g_pDynArraySByte = 0;
static OpcUa_VariantArrayValue *g_pDynArrayByte = 0;
static OpcUa_VariantArrayValue *g_pDynArrayInt16 = 0;
static OpcUa_VariantArrayValue *g_pDynArrayUInt16 = 0;
static OpcUa_VariantArrayValue *g_pDynArrayInt32 = 0;
static OpcUa_VariantArrayValue *g_pDynArrayUInt32 = 0;
static OpcUa_VariantArrayValue *g_pDynArrayInt64 = 0;
static OpcUa_VariantArrayValue *g_pDynArrayUInt64 = 0;
static OpcUa_VariantArrayValue *g_pDynArrayFloat = 0;
static OpcUa_VariantArrayValue *g_pDynArrayDouble = 0;
static OpcUa_VariantArrayValue *g_pDynArrayDateTime = 0;
static OpcUa_VariantArrayValue *g_pDynArrayString = 0;
static OpcUa_VariantArrayValue *g_pDynArrayGuid = 0;
static OpcUa_VariantArrayValue *g_pDynArrayByteString = 0;
static OpcUa_VariantArrayValue *g_pDynArrayLocalizedText = 0;
static OpcUa_VariantArrayValue *g_pDynArrayQualifiedName = 0;
static OpcUa_VariantArrayValue *g_pDynArrayNodeId = 0;
static OpcUa_VariantArrayValue *g_pDynArrayExpandedNodeId = 0;
static OpcUa_VariantArrayValue *g_pDynArrayStatusCode = 0;
static OpcUa_VariantArrayValue *g_pDynArrayXmlElement = 0;
#if UAPROVIDER_DEMO_HAVE_MASS_ITEMS
static OpcUa_UInt32 *g_pMassDynUInt32[UAPROVIDER_DEMO_NUM_MASS_DYNAMIC_VARIABLES];
#endif
static OpcUa_Double *g_pHistoryDouble = 0;
static OpcUa_Byte *g_pHistoryByte = 0;
#if UAPROVIDER_DEMO_HAVE_ANIMATION_ITEM
#endif
static BoilerType g_Boiler1;
#if HAVE_DATA_LOGGER
static OpcUa_Int g_hDataLogger = 0;
static OpcUa_Int g_hDataLogItemDouble = 0;
#endif
#if UASERVER_SUPPORT_EVENTS
static Machine g_machine;
#endif
struct _ItemVariableMapping
{
void **ppVariable;
const char* szNodeId;
};
typedef struct _ItemVariableMapping ItemVariableMapping;
static ItemVariableMapping g_Items[] =
{
#if HAVE_DATA_LOGGER
{ (void**) &g_pDataLoggerActive, Demo_Objects_Demo_History_DataLoggerActive },
#endif
{ (void**) &g_pSimulationSpeed, Demo_Objects_Demo_SimulationSpeed },
{ (void**) &g_pSimulationActive, Demo_Objects_Demo_SimulationActive },
{ (void**) &g_pDynBoolean, Demo_Objects_Demo_Dynamic_Scalar_Boolean },
{ (void**) &g_pDynByte, Demo_Objects_Demo_Dynamic_Scalar_Byte },
{ (void**) &g_pDynSByte, Demo_Objects_Demo_Dynamic_Scalar_SByte },
{ (void**) &g_pDynUInt16, Demo_Objects_Demo_Dynamic_Scalar_UInt16 },
{ (void**) &g_pDynInt16, Demo_Objects_Demo_Dynamic_Scalar_Int16 },
{ (void**) &g_pDynUInt32, Demo_Objects_Demo_Dynamic_Scalar_UInt32 },
{ (void**) &g_pDynInt32, Demo_Objects_Demo_Dynamic_Scalar_Int32 },
{ (void**) &g_pDynUInt64, Demo_Objects_Demo_Dynamic_Scalar_UInt64 },
{ (void**) &g_pDynInt64, Demo_Objects_Demo_Dynamic_Scalar_Int64 },
{ (void**) &g_pDynFloat, Demo_Objects_Demo_Dynamic_Scalar_Float },
{ (void**) &g_pDynDouble, Demo_Objects_Demo_Dynamic_Scalar_Double },
{ (void**) &g_pDynDateTime, Demo_Objects_Demo_Dynamic_Scalar_DateTime },
{ (void**) &g_pDynString, Demo_Objects_Demo_Dynamic_Scalar_String },
{ (void**) &g_pDynByteString, Demo_Objects_Demo_Dynamic_Scalar_ByteString },
{ (void**) &g_ppDynGuid, Demo_Objects_Demo_Dynamic_Scalar_Guid },
{ (void**) &g_ppDynLocalizedText, Demo_Objects_Demo_Dynamic_Scalar_LocalizedText },
{ (void**) &g_ppDynQualifiedName, Demo_Objects_Demo_Dynamic_Scalar_QualifiedName },
{ (void**) &g_ppDynNodeId, Demo_Objects_Demo_Dynamic_Scalar_NodeId },
{ (void**) &g_ppDynExpandedNodeId, Demo_Objects_Demo_Dynamic_Scalar_ExpandedNodeId },
{ (void**) &g_pDynStatusCode, Demo_Objects_Demo_Dynamic_Scalar_StatusCode },
{ (void**) &g_pDynXmlElement, Demo_Objects_Demo_Dynamic_Scalar_XmlElement },
{ (void**) &g_pDynamicValue, Demo_Objects_Demo_Dynamic_Scalar_Quality_DynamicValue },
{ (void**) &g_pDynArrayBoolean, Demo_Objects_Demo_Dynamic_Arrays_Boolean },
{ (void**) &g_pDynArrayByte, Demo_Objects_Demo_Dynamic_Arrays_Byte },
{ (void**) &g_pDynArraySByte, Demo_Objects_Demo_Dynamic_Arrays_SByte },
{ (void**) &g_pDynArrayUInt16, Demo_Objects_Demo_Dynamic_Arrays_UInt16 },
{ (void**) &g_pDynArrayInt16, Demo_Objects_Demo_Dynamic_Arrays_Int16 },
{ (void**) &g_pDynArrayUInt32, Demo_Objects_Demo_Dynamic_Arrays_UInt32 },
{ (void**) &g_pDynArrayInt32, Demo_Objects_Demo_Dynamic_Arrays_Int32 },
{ (void**) &g_pDynArrayUInt64, Demo_Objects_Demo_Dynamic_Arrays_UInt64 },
{ (void**) &g_pDynArrayInt64, Demo_Objects_Demo_Dynamic_Arrays_Int64 },
{ (void**) &g_pDynArrayFloat, Demo_Objects_Demo_Dynamic_Arrays_Float },
{ (void**) &g_pDynArrayDouble, Demo_Objects_Demo_Dynamic_Arrays_Double },
{ (void**) &g_pDynArrayGuid, Demo_Objects_Demo_Dynamic_Arrays_Guid },
{ (void**) &g_pDynArrayDateTime, Demo_Objects_Demo_Dynamic_Arrays_DateTime },
{ (void**) &g_pDynArrayString, Demo_Objects_Demo_Dynamic_Arrays_String },
{ (void**) &g_pDynArrayByteString, Demo_Objects_Demo_Dynamic_Arrays_ByteString },
{ (void**) &g_pDynArrayLocalizedText, Demo_Objects_Demo_Dynamic_Arrays_LocalizedText },
{ (void**) &g_pDynArrayQualifiedName, Demo_Objects_Demo_Dynamic_Arrays_QualifiedName },
{ (void**) &g_pDynArrayNodeId, Demo_Objects_Demo_Dynamic_Arrays_NodeId },
{ (void**) &g_pDynArrayExpandedNodeId, Demo_Objects_Demo_Dynamic_Arrays_ExpandedNodeId },
{ (void**) &g_pDynArrayStatusCode, Demo_Objects_Demo_Dynamic_Arrays_StatusCode },
{ (void**) &g_pDynArrayXmlElement, Demo_Objects_Demo_Dynamic_Arrays_XmlElement },
{ (void**) &g_pHistoryByte, Demo_Objects_Demo_History_ByteWithHistory },
{ (void**) &g_pHistoryDouble, Demo_Objects_Demo_History_DoubleWithHistory },
{ 0, 0 }
};
OPCUA_BEGIN_EXTERN_C
{
OpcUa_BaseNode *pNode = 0;
if (pNode && OpcUa_BaseNode_GetType(pNode) == eVariable)
{
}
return pVal;
}
OpcUa_Variant* UaProvider_Demo_GetNodeValueString(
const char *szId)
{
OpcUa_BaseNode *pNode = 0;
if (pNode && OpcUa_BaseNode_GetType(pNode) == eVariable)
{
}
return pVal;
}
#if UAPROVIDER_DEMO_HAVE_MASS_ITEMS
{
OpcUa_BaseNode *pNode = 0;
OpcUa_DataVariable *pVariable = 0;
char szName[50];
int i;
OpcUa_InitializeStatus(OpcUa_Module_Server, "UaProvider_Demo_CreateNodes");
OpcUa_Variant_Initialize(&value);
#if UAPROVIDER_DEMO_HAVE_ANIMATION_ITEM
if (pVal)
{
g_pAnimation = &pVal->
Value.ByteString;
}
#endif
value.
Value.UInt32 = 123;
for (i=0; i<UAPROVIDER_DEMO_NUM_MASS_STATIC_VARIABLES; i++)
{
OpcUa_SnPrintfA(szName, 50, "Variable%03i", i);
OpcUa_GotoErrorIfBad(uStatus);
}
for (i=0; i<UAPROVIDER_DEMO_NUM_MASS_DYNAMIC_VARIABLES; i++)
{
OpcUa_SnPrintfA(szName, 50, "Variable%03i", i);
uStatus =
UaServer_CreateDataVariable(pAddressSpace, &pVariable, pNode, 20000+UAPROVIDER_DEMO_NUM_MASS_STATIC_VARIABLES+i, g_UaProviderDemo_uNamespaceIndex1, szName);
OpcUa_GotoErrorIfBad(uStatus);
if (pVal)
{
g_pMassDynUInt32[i] = &pVal->
Value.UInt32;
}
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
#endif
#if HAVE_DATA_LOGGER
{
HistoryDataLogger *pUserDataHistoryDataLogger = 0;
UaServer_DataLog *pDataLogItem;
OpcUa_Int32 iSamplingInterval = 500;
OpcUa_BaseNode *pNode = 0;
OpcUa_Byte AccessLevel;
if (pNode)
{
pUserDataHistoryDataLogger = (HistoryDataLogger*)OpcUa_Alloc(sizeof(HistoryDataLogger));
OpcUa_ReturnErrorIfAllocFailed(pUserDataHistoryDataLogger);
if (UaServer_DataLogger_FindDataLogItem(g_hDataLogger, pId, &pDataLogItem) == OpcUa_Good)
{
iSamplingInterval = (OpcUa_Int32)pDataLogItem->SamplingRate;
}
if (bStartLogging == OpcUa_False)
{
}
iSamplingInterval,
monitoringMode,
100,
OpcUa_Null,
g_hDataLogger,
&g_hDataLogItemDouble);
if (OpcUa_IsBad(uStatus) != OpcUa_False)
{
OpcUa_Free(pUserDataHistoryDataLogger);
OpcUa_ReturnError(uStatus);
}
pUserDataHistoryDataLogger->Type = UserDataType_HistoryDataLogger;
pUserDataHistoryDataLogger->DataLogger = g_hDataLogger;
pUserDataHistoryDataLogger->DataLogItem = g_hDataLogItemDouble;
AccessLevel |= OpcUa_AccessLevels_HistoryRead;
}
return OpcUa_Good;
}
void UaProvider_Demo_EnableHistorizedItem(
OpcUa_NodeId *pId, OpcUa_Boolean bEnabled)
{
HistoryDataLogger *pUserDataHistoryDataLogger = 0;
OpcUa_BaseNode *pNode = 0;
UaServer_DataLog *pDataLogItem;
OpcUa_Int32 iSamplingInterval = 500;
if (pNode)
{
if (pUserDataHistoryDataLogger == 0) return;
if (UaServer_DataLogger_FindDataLogItem(g_hDataLogger, pId, &pDataLogItem) == OpcUa_Good)
{
iSamplingInterval = (OpcUa_Int32)pDataLogItem->SamplingRate;
}
g_hDataLogger,
pUserDataHistoryDataLogger->DataLogItem,
iSamplingInterval,
monitoringMode,
100,
OpcUa_Null
);
}
}
{
OpcUa_Boolean bStartLogging;
char szDataLoggerPath[512] = "";
#if defined(__WIN32) || defined(WIN32)
#else
#endif
if (szDataLoggerPath[0] == '\0') return OpcUa_Good;
#if HAVE_DATA_LOGGER_SQLITE_BACKEND
g_hDataLogger = UaServer_SQLiteLogger_Create( szDataLoggerPath, 600, 5);
#elif HAVE_DATA_LOGGER_FILE_BACKEND
#elif !defined(VXWORKS)
# error "Configuration error. No datalogger is configured."
#endif
OpcUa_ReturnErrorIfTrue(g_hDataLogger < 0, OpcUa_BadConfigurationError);
uStatus = UaProvider_Demo_HistorizeItem(&nodeId, bStartLogging);
OpcUa_ReturnErrorIfBad(uStatus);
uStatus = UaProvider_Demo_HistorizeItem(&nodeId, bStartLogging);
OpcUa_ReturnErrorIfBad(uStatus);
uStatus = UaProvider_Demo_HistorizeItem(&nodeId, bStartLogging);
OpcUa_ReturnErrorIfBad(uStatus);
if (g_pDataLoggerActive) *g_pDataLoggerActive = bStartLogging;
return OpcUa_Good;
}
void UaProvider_Demo_CleanupDataLogger()
{
OpcUa_BaseNode *pNode;
UserDataCommon *pUserData;
if (pNode)
{
if (pUserData)
{
if (pUserData->Type == UserDataType_HistoryDataLogger)
{
HistoryDataLogger *pUserDataHistoryDataLogger = (HistoryDataLogger*)pUserData;
}
OpcUa_Free(pUserData);
}
}
if (pNode)
{
if (pUserData)
{
if (pUserData->Type == UserDataType_HistoryDataLogger)
{
HistoryDataLogger *pUserDataHistoryDataLogger = (HistoryDataLogger*)pUserData;
}
OpcUa_Free(pUserData);
}
}
if (pNode)
{
if (pUserData)
{
if (pUserData->Type == UserDataType_HistoryDataLogger)
{
HistoryDataLogger *pUserDataHistoryDataLogger = (HistoryDataLogger*)pUserData;
}
OpcUa_Free(pUserData);
}
}
UaServer_DataLogger_Delete(g_hDataLogger);
}
{
if (g_pDataLoggerActive == 0) return OpcUa_BadInternalError;
if (*g_pDataLoggerActive) return OpcUa_BadInvalidState;
*g_pDataLoggerActive = OpcUa_True;
UaProvider_Demo_EnableHistorizedItem(&nodeId, OpcUa_True);
UaProvider_Demo_EnableHistorizedItem(&nodeId, OpcUa_True);
UaProvider_Demo_EnableHistorizedItem(&nodeId, OpcUa_True);
return OpcUa_Good;
}
{
if (g_pDataLoggerActive == 0) return OpcUa_BadInternalError;
if (*g_pDataLoggerActive == OpcUa_False) return OpcUa_BadInvalidState;
UaProvider_Demo_EnableHistorizedItem(&nodeId, OpcUa_False);
UaProvider_Demo_EnableHistorizedItem(&nodeId, OpcUa_False);
UaProvider_Demo_EnableHistorizedItem(&nodeId, OpcUa_False);
*g_pDataLoggerActive = OpcUa_False;
return OpcUa_Good;
}
#endif
#if UASERVER_SUPPORT_UNITS
void UaProvider_Demo_SetEngineeringUnits(const char *szNodeId, const char *szCommonCode)
{
OpcUa_Int32 UnitId = UaServer_UnitIdFromCommonCode(szCommonCode);
pVal = UaProvider_Demo_GetNodeValueString(szNodeId);
if ( pVal
&& pVal->
Datatype == OpcUaType_ExtensionObject
&& pVal->
Value.ExtensionObject->Body.EncodeableObject.Type->TypeId == OpcUaId_EUInformation)
{
pEUInfoSrc = UaServer_EUInformationFromUnitId(UnitId);
if (pEUInfoSrc && pEUInfoDst)
{
OpcUa_EUInformation_Clear(pEUInfoDst);
}
}
}
#endif
#if UASERVER_SUPPORT_AUTHORIZATION
struct NodePermission
{
int id;
const char *szId;
const char *szOwner;
const char *szGroup;
const char *szMode;
};
static struct NodePermission g_permissions[] =
{
{0, Demo_Objects_Demo_AccessRights_Browse_All,
"john", "operators", "-br---br---br---"},
{0, Demo_Objects_Demo_AccessRights_Browse_John,
"john", "operators", "-br-------------"},
{0, Demo_Objects_Demo_AccessRights_Browse_Operators,
"john", "operators", "-br---br--------"},
{0, Demo_Objects_Demo_AccessRights_Access_John_All_RO_John_RW,
"john", "operators", "-brw--br---br---"},
{0, Demo_Objects_Demo_AccessRights_Access_John_All_WO_John_RW,
"john", "operators", "-brw--b-w--b-w--"},
{0, Demo_Objects_Demo_AccessRights_Access_John_John_RO,
"john", "operators", "-br---b----b----"},
{0, Demo_Objects_Demo_AccessRights_Access_John_John_RW,
"john", "operators", "-brw--b----b----"},
{0, Demo_Objects_Demo_AccessRights_Access_John_John_WO,
"john", "operators", "-b-w--b----b----"},
{0, Demo_Objects_Demo_AccessRights_Access_Operators_All_RO_Operators_RW,
"john", "operators", "-brw--brw--br---"},
{0, Demo_Objects_Demo_AccessRights_Access_Operators_All_WO_Operators_RW,
"john", "operators", "-brw--brw--b-w--"},
{0, Demo_Objects_Demo_AccessRights_Access_Operators_Operators_RO,
"john", "operators", "-br---br---b----"},
{0, Demo_Objects_Demo_AccessRights_Access_Operators_Operators_RW,
"john", "operators", "-brw--brw--b----"},
{0, Demo_Objects_Demo_AccessRights_Access_Operators_Operators_WO,
"john", "operators", "-b-w--b-w--b----"},
{0, Demo_Objects_Demo_CTT_SecurityAccess_AccessLevel_CurrentRead,
"sue", "sue", "-brw--brw--brw--"},
{0, Demo_Objects_Demo_CTT_SecurityAccess_AccessLevel_CurrentRead_NotCurrentWrite,
"sue", "sue", "-br---br---br---"},
{0, Demo_Objects_Demo_CTT_SecurityAccess_AccessLevel_CurrentRead_NotUser,
"sue", "sue", "-brw--b-w--b-w--"},
{0, Demo_Objects_Demo_CTT_SecurityAccess_AccessLevel_CurrentWrite,
"sue", "sue", "-brw--brw--brw--"},
{0, Demo_Objects_Demo_CTT_SecurityAccess_AccessLevel_CurrentWrite_NotCurrentRead,
"sue", "sue", "-b-w--b-w--b-w--"},
{0, Demo_Objects_Demo_CTT_SecurityAccess_AccessLevel_CurrentWrite_NotUser,
"sue", "sue", "-brw--br---br---"}
};
static int g_numPermissions = sizeof(g_permissions)/sizeof(struct NodePermission);
void UaProvider_Demo_SetupAccessRights()
{
OpcUa_BaseNode *pNode = 0;
OpcUa_UInt16 mode;
OpcUa_uid_t uid;
OpcUa_gid_t gid;
int i;
for (i=0; i<g_numPermissions; i++)
{
if (OpcUa_IsBad(ret)) continue;
OpcUa_String_Clear(&pass_hash);
if (OpcUa_IsBad(ret)) continue;
mode = 0;
if (g_permissions[i].id == 0)
{
}
else
{
}
if (pNode == 0) continue;
}
}
#endif
{
OpcUa_BaseNode *pNode = OpcUa_Null;
MultiStateDiscreteRange *pRange = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_Server, "MultiStateDiscreteRange_Create");
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNodeIdUnknown);
pRange = OpcUa_Alloc(sizeof(MultiStateDiscreteRange));
OpcUa_GotoErrorIfNull(pRange, OpcUa_BadOutOfMemory);
pRange->Type = UserDataType_MultiStateDiscrete;
pRange->MinValue = minValue;
pRange->MaxValue = maxValue;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
{
OpcUa_BaseNode *pNode = OpcUa_Null;
MultiStateDiscreteRange *pRange = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_Server, "MultiStateDiscreteRange_Delete");
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNodeIdUnknown);
OpcUa_GotoErrorIfNull(pRange, OpcUa_BadInvalidArgument);
OpcUa_Free(pRange);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_StatusCode UaProvider_Demo_SetWorkOrderType_Reference(
const OpcUa_CharA *a_szNodeIdentifier,
WorkOrderTypeReference_Field a_field)
{
OpcUa_BaseNode *pNode;
OpcUa_InitializeStatus(OpcUa_Module_Server, "UaProvider_Demo_SetWorkOrderType_Reference");
if (pNode)
{
WorkOrderTypeReference *pWorkOrderTypeReference = OpcUa_Alloc(sizeof(WorkOrderTypeReference));
OpcUa_GotoErrorIfAllocFailed(pWorkOrderTypeReference);
pWorkOrderTypeReference->Type = UserDataType_WorkOrderTypeReference;
pWorkOrderTypeReference->pWorkOrderType = a_pValue;
pWorkOrderTypeReference->Field = a_field;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
OpcUa_Void UaProvider_Demo_FreeUserData(const OpcUa_CharA *a_szNodeIdentifier)
{
OpcUa_BaseNode *pNode;
if (pNode)
{
}
}
#define SET_MATRIX_VALUE(NODEID, DATATYPE) \
{ \
OpcUa_Int32 iNumArrayDimensions, iNumElements; \
OpcUa_UInt32 *pArrayDimensions; \
\
UaBase_CreateStringNodeId(&nodeid, NODEID); \
pNode = UaServer_GetNodeById(&nodeid); \
pValue = OpcUa_Variable_GetValue(pNode); \
iNumArrayDimensions = OpcUa_Variable_GetNumArrayDimensions(pNode); \
pArrayDimensions = OpcUa_Variable_GetArrayDimensions(pNode); \
\
OpcUa_Variant_Clear(pValue); \
iNumElements = 1; \
pValue->Datatype = OpcUaType_##DATATYPE; \
pValue->ArrayType = OpcUa_VariantArrayType_Matrix; \
pValue->Value.Matrix.Dimensions = OpcUa_Alloc(iNumArrayDimensions * sizeof(OpcUa_Int32)); \
OpcUa_GotoErrorIfAllocFailed(pValue->Value.Matrix.Dimensions); \
pValue->Value.Matrix.NoOfDimensions = iNumArrayDimensions; \
for (i = 0; i < iNumArrayDimensions; i++) \
{ \
pValue->Value.Matrix.Dimensions[i] = pArrayDimensions[i]; \
iNumElements *= pArrayDimensions[i]; \
} \
pValue->Value.Matrix.Value.DATATYPE##Array = OpcUa_Alloc(iNumElements * sizeof(OpcUa_##DATATYPE)); \
OpcUa_GotoErrorIfAllocFailed(pValue->Value.Matrix.Value.DATATYPE##Array); \
for (i = 0; i < iNumElements; i++) \
{ \
OpcUa_##DATATYPE##_Initialize(&pValue->Value.Matrix.Value.DATATYPE##Array[i]); \
} \
}
{
OpcUa_BaseNode *pNode = 0;
OpcUa_Int32 i, uLength = 80 * 1024;
OpcUa_CharA *szLongDesc;
OpcUa_InitializeStatus(OpcUa_Module_Server, "UaProvider_Demo_SetupCustomNodeValues");
#if !OPCUA_VARIANT_OMIT_MATRIX
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Boolean, Boolean)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Byte, Byte)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_ByteString,
ByteString)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_DateTime, DateTime)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Double, Double)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_ExpandedNodeId, ExpandedNodeId)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Float, Float)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Guid,
Guid)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Int16, Int16)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Int32, Int32)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_Int64, Int64)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_LocalizedText, LocalizedText)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_NodeId, NodeId)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_QualifiedName, QualifiedName)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_SByte, SByte)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_StatusCode, StatusCode)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_String,
String)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_UInt16, UInt16)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_UInt32, UInt32)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_UInt64, UInt64)
SET_MATRIX_VALUE(Demo_Objects_Demo_Static_Matrix_XmlElement, XmlElement)
{
OpcUa_Int32 iNumArrayDimensions, iNumElements;
OpcUa_UInt32 *pArrayDimensions;
OpcUa_Variant_Clear(pValue);
iNumElements = 1;
pValue->
Datatype = OpcUaType_ExtensionObject;
pValue->
ArrayType = OpcUa_VariantArrayType_Matrix;
pValue->
Value.Matrix.Dimensions = OpcUa_Alloc(iNumArrayDimensions *
sizeof(OpcUa_Int32));
OpcUa_GotoErrorIfAllocFailed(pValue->
Value.Matrix.Dimensions);
pValue->
Value.Matrix.NoOfDimensions = iNumArrayDimensions;
for (i = 0; i < iNumArrayDimensions; i++)
{
pValue->
Value.Matrix.Dimensions[i] = pArrayDimensions[i];
iNumElements *= pArrayDimensions[i];
}
OpcUa_GotoErrorIfAllocFailed(pValue->
Value.Matrix.Value.ExtensionObjectArray);
for (i = 0; i < iNumElements; i++)
{
Demo_Vector *pVector = OpcUa_Null;
OpcUa_ExtensionObject_Initialize(&pValue->
Value.Matrix.Value.ExtensionObjectArray[i]);
uStatus = OpcUa_EncodeableObject_CreateExtension(&Demo_Vector_EncodeableType,
&pValue->
Value.Matrix.Value.ExtensionObjectArray[i],
(OpcUa_Void**)&pVector);
OpcUa_GotoErrorIfBad(uStatus);
}
}
#endif
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNotFound);
szLongDesc = OpcUa_Alloc(uLength);
OpcUa_GotoErrorIfAllocFailed(szLongDesc);
for (i = 0; i < uLength; i++) { szLongDesc[i] = 'a' + (i % 26); }
szLongDesc[uLength - 1] = '\0';
uStatus = OpcUa_String_AttachToString(szLongDesc,
uLength - 1,
uLength,
OpcUa_False,
OpcUa_True,
OpcUa_GotoErrorIfBad(uStatus);
#define SET_SCALAR_UINT32(NODEID) \
UaBase_CreateStringNodeId(&nodeid, NODEID); \
pNode = UaServer_GetNodeById(&nodeid); \
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNotFound); \
pValue = OpcUa_Variable_GetValue(pNode); \
OpcUa_Variant_Clear(pValue); \
OpcUa_Variant_SetUInt32(pValue, 0);
SET_SCALAR_UINT32(Demo_Objects_Demo_Static_Scalar_BaseDataType);
SET_SCALAR_UINT32(Demo_Objects_Demo_Static_Scalar_Integer);
SET_SCALAR_UINT32(Demo_Objects_Demo_Static_Scalar_Number);
SET_SCALAR_UINT32(Demo_Objects_Demo_Static_Scalar_UInteger);
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNotFound);
uStatus = OpcUa_EncodeableObject_CreateExtension(&OpcUa_AxisInformation_EncodeableType,
pValue->
Value.ExtensionObject,
(OpcUa_Void**)&pAxisInformation);
OpcUa_GotoErrorIfBad(uStatus);
#define SET_ARRAY_UINT32(NODEID) \
UaBase_CreateStringNodeId(&nodeid, NODEID); \
pNode = UaServer_GetNodeById(&nodeid); \
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNotFound); \
pValue = OpcUa_Variable_GetValue(pNode); \
OpcUa_Variant_Clear(pValue); \
pValue->Value.Array.Value.UInt32Array = OpcUa_Alloc(10 * sizeof(OpcUa_UInt32)); \
OpcUa_GotoErrorIfAllocFailed(pValue->Value.Array.Value.UInt32Array); \
OpcUa_MemSet(pValue->Value.Array.Value.UInt32Array, 0, 10 * sizeof(OpcUa_UInt32)); \
pValue->Value.Array.Length = 10; \
pValue->Datatype = OpcUaType_UInt32; \
pValue->ArrayType = OpcUa_VariantArrayType_Array;
SET_ARRAY_UINT32(Demo_Objects_Demo_Static_Arrays_BaseDataType);
SET_ARRAY_UINT32(Demo_Objects_Demo_Static_Arrays_Integer);
SET_ARRAY_UINT32(Demo_Objects_Demo_Static_Arrays_Number);
SET_ARRAY_UINT32(Demo_Objects_Demo_Static_Arrays_UInteger);
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNotFound);
OpcUa_Variant_Clear(pValue);
OpcUa_GotoErrorIfAllocFailed(pValue->
Value.Array.Value.ExtensionObjectArray);
pValue->
Value.Array.Length = 10;
pValue->
Datatype = OpcUaType_ExtensionObject;
pValue->
ArrayType = OpcUa_VariantArrayType_Array;
for (i = 0; i < pValue->
Value.Array.Length; i++)
{
uStatus = OpcUa_EncodeableObject_CreateExtension(&OpcUa_AxisInformation_EncodeableType,
&pValue->
Value.Array.Value.ExtensionObjectArray[i],
(OpcUa_Void**)&pAxisInformation);
OpcUa_GotoErrorIfBad(uStatus);
}
SET_SCALAR_UINT32(Demo_Objects_Demo_CTT_Static_All_Profiles_Scalar_Integer);
SET_SCALAR_UINT32(Demo_Objects_Demo_CTT_Static_All_Profiles_Scalar_Number);
SET_SCALAR_UINT32(Demo_Objects_Demo_CTT_Static_All_Profiles_Scalar_UInteger);
SET_SCALAR_UINT32(Demo_Objects_Demo_CTT_Static_All_Profiles_Scalar_Variant);
OpcUa_GotoErrorIfNull(pNode, OpcUa_BadNotFound);
OpcUa_Variant_Clear(pValue);
OpcUa_GotoErrorIfAllocFailed(pValue->
Value.Array.Value.VariantArray);
pValue->
Value.Array.Length = 10;
pValue->
ArrayType = OpcUa_VariantArrayType_Array;
for (i = 0; i < pValue->
Value.Array.Length; i += 5)
{
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
{
OpcUa_BaseNode *pNode = 0;
#if UASERVER_SUPPORT_EVENTS
#endif
int iItem = 0;
OpcUa_InitializeStatus(OpcUa_Module_Server, "UaProvider_Demo_InitializeSimulation");
#if UAPROVIDER_DEMO_HAVE_MASS_ITEMS
uStatus = UaProvider_Demo_CreateNodes();
OpcUa_GotoErrorIfBad(uStatus);
#endif
while (g_Items[iItem].ppVariable != 0)
{
pVal = UaProvider_Demo_GetNodeValueString(g_Items[iItem].szNodeId);
if (pVal)
{
if (pVal->
ArrayType == OpcUa_VariantArrayType_Scalar)
{
*g_Items[iItem].ppVariable = &pVal->
Value.Boolean;
}
else if (pVal->
ArrayType == OpcUa_VariantArrayType_Array)
{
*g_Items[iItem].ppVariable = &pVal->
Value.Array;
}
}
++iItem;
}
g_Boiler1.Type = UserDataType_BoilerType;
pVal = UaProvider_Demo_GetNodeValueString(Demo_Objects_Demo_BoilerDemo_Boiler1_TemperatureSensor_Temperature);
if (pVal) g_Boiler1.pTemperature = &pVal->
Value.Double;
pVal = UaProvider_Demo_GetNodeValueString(Demo_Objects_Demo_BoilerDemo_Boiler1_TemperatureSetPoint);
if (pVal) g_Boiler1.pTemperatureSetPoint = &pVal->
Value.Double;
pVal = UaProvider_Demo_GetNodeValueString(Demo_Objects_Demo_BoilerDemo_Boiler1_FillLevelSensor_FillLevel);
if (pVal) g_Boiler1.pFillLevel = &pVal->
Value.Double;
pVal = UaProvider_Demo_GetNodeValueString(Demo_Objects_Demo_BoilerDemo_Boiler1_FillLevelSetPoint);
if (pVal) g_Boiler1.pFillLevelSetPoint = &pVal->
Value.Double;
pVal = UaProvider_Demo_GetNodeValueString(Demo_Objects_Demo_BoilerDemo_Boiler1_HeaterStatus);
if (pVal) g_Boiler1.pHeaterStatus = &pVal->
Value.Int32;
#if UASERVER_SUPPORT_UNITS
UaProvider_Demo_SetEngineeringUnits(Demo_Objects_Demo_BoilerDemo_Boiler1_TemperatureSensor_Temperature_EngineeringUnits, "CEL");
UaProvider_Demo_SetEngineeringUnits(Demo_Objects_Demo_BoilerDemo_Boiler1_FillLevelSensor_FillLevel_EngineeringUnits, "LTR");
#endif
if (g_Boiler1.pTemperature) *g_Boiler1.pTemperature = 20;
if (g_Boiler1.pTemperatureSetPoint) *g_Boiler1.pTemperatureSetPoint = 90;
if (g_Boiler1.pFillLevel) *g_Boiler1.pFillLevel = 10;
if (g_Boiler1.pFillLevelSetPoint) *g_Boiler1.pFillLevelSetPoint = 50;
#if UASERVER_SUPPORT_EVENTS
pVal = UaProvider_Demo_GetNodeValueNumeric(Demo_Objects_Machine_TemperatureSensor_Temperature);
if (pVal)
{
pVal->
Value.Double = 25.0;
g_machine.TemperatureSensor.pValue = &pVal->
Value.Double;
}
pVal = UaProvider_Demo_GetNodeValueNumeric(Demo_Objects_Machine_HeaterSwitch);
if (pVal)
{
g_machine.HeaterSwitch.pValue = &pVal->
Value.Boolean;
}
UaProvider_Demo_InitializeAlarmConditionTypeEvent(
pEvent,
&g_machine.TemperatureSensor.NodeId,
"Temperature Sensor",
&g_machine.TemperatureSensor.HighAlarmId,
"HighAlarm");
UaProvider_Demo_InitializeAlarmConditionTypeEvent(
pEvent,
&g_machine.TemperatureSensor.NodeId,
"Temperature Sensor",
&g_machine.TemperatureSensor.LowAlarmId,
"LowAlarm");
#endif
uStatus = MultiStateDiscreteRange_Create(&nodeid, 0, 4);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = MultiStateDiscreteRange_Create(&nodeid, 0, 4);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = MultiStateDiscreteRange_Create(&nodeid, 0, 2);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = MultiStateDiscreteRange_Create(&nodeid, 0, 2);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = MultiStateDiscreteRange_Create(&nodeid, 0, 2);
OpcUa_GotoErrorIfBad(uStatus);
if (pNode)
{
QualityInformation *pInfo = OpcUa_Alloc(sizeof(QualityInformation));
OpcUa_GotoErrorIfAllocFailed(pInfo);
pInfo->Type = UserDataType_Quality;
pInfo->Quality = OpcUa_Good;
g_pDynamicValue_Quality = &pInfo->Quality;
}
if (pNode)
{
QualityInformation *pInfo = OpcUa_Alloc(sizeof(QualityInformation));
OpcUa_GotoErrorIfAllocFailed(pInfo);
pInfo->Type = UserDataType_Quality;
pInfo->Quality = OpcUa_Good;
g_pStaticValue_Quality = &pInfo->Quality;
}
if (pNode)
{
OpcUa_GotoErrorIfNull(pValue, OpcUa_BadInternalError);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_ID,
pValue,
WorkOrderTypeField_ID);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_AssetID,
pValue,
WorkOrderTypeField_AssetID);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_StartTime,
pValue,
WorkOrderTypeField_StartTime);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_StatusComments,
pValue,
WorkOrderTypeField_StatusComments);
OpcUa_GotoErrorIfBad(uStatus);
}
if (pNode)
{
OpcUa_GotoErrorIfNull(pValue, OpcUa_BadInternalError);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_ID,
pValue,
WorkOrderTypeField_ID);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_AssetID,
pValue,
WorkOrderTypeField_AssetID);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_StartTime,
pValue,
WorkOrderTypeField_StartTime);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetWorkOrderType_Reference(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_StatusComments,
pValue,
WorkOrderTypeField_StatusComments);
OpcUa_GotoErrorIfBad(uStatus);
}
#if HAVE_DATA_LOGGER
uStatus = UaProvider_Demo_SetupDataLogger();
OpcUa_GotoErrorIfBad(uStatus);
#endif
#if UASERVER_SUPPORT_AUTHORIZATION
UaProvider_Demo_SetupAccessRights();
#endif
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaProvider_Demo_SetupCustomNodeValues();
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
void UaProvider_Demo_CleanupSimulation()
{
#if UASERVER_SUPPORT_EVENTS
#endif
#if HAVE_DATA_LOGGER
UaProvider_Demo_CleanupDataLogger();
#endif
MultiStateDiscreteRange_Delete(&nodeid);
MultiStateDiscreteRange_Delete(&nodeid);
MultiStateDiscreteRange_Delete(&nodeid);
MultiStateDiscreteRange_Delete(&nodeid);
MultiStateDiscreteRange_Delete(&nodeid);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_Dynamic_Scalar_Quality_DynamicValue);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_Dynamic_Scalar_Quality_StaticValue);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_ID);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_AssetID);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_StartTime);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable_StatusComments);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_ID);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_AssetID);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_StartTime);
UaProvider_Demo_FreeUserData(Demo_Objects_Demo_WorkOrder_WorkOrderVariable2_StatusComments);
}
{
if (g_hSimulationTimer != 0) return OpcUa_BadInvalidState;
ret = OpcUa_Timer_Create(
&g_hSimulationTimer,
g_SimulationInterval,
UaProvider_Demo_SimulationTimer,
OpcUa_Null,
OpcUa_Null );
if (g_pSimulationActive)
{
*g_pSimulationActive = OpcUa_True;
}
if (g_pSimulationSpeed)
{
*g_pSimulationSpeed = g_SimulationInterval;
}
return ret;
}
{
if (g_hSimulationTimer == 0) return OpcUa_BadInvalidState;
ret = OpcUa_Timer_Delete(&g_hSimulationTimer);
if (g_pSimulationActive)
{
*g_pSimulationActive = OpcUa_False;
}
return ret;
}
{
if (g_SimulationInterval == interval) return ret;
g_SimulationInterval = interval;
if (g_hSimulationTimer)
{
UaProvider_Demo_StopSimulation();
UaProvider_Demo_StartSimulation();
}
if (g_pSimulationSpeed)
{
*g_pSimulationSpeed = g_SimulationInterval;
}
return ret;
}
#if UAPROVIDER_DEMO_HAVE_ANIMATION_ITEM && UABASE_USE_FILESYSTEM
{
if (g_hAnimationTimer != 0) return OpcUa_BadInvalidState;
ret = OpcUa_Timer_Create(
&g_hAnimationTimer,
g_AnimationInterval,
UaProvider_Demo_AnimationTimer,
OpcUa_Null,
OpcUa_Null );
return ret;
}
{
if (g_hAnimationTimer == 0) return OpcUa_BadInvalidState;
ret = OpcUa_Timer_Delete(&g_hAnimationTimer);
return ret;
}
{
if (g_AnimationInterval == interval) return ret;
g_AnimationInterval = interval;
if (g_hAnimationTimer)
{
UaProvider_Demo_StopAnimation();
UaProvider_Demo_StartAnimation();
}
return ret;
}
#endif
static void UaProvider_Demo_SimulateDynamicVariables()
{
static char szText[] = "*** stone - paper - scissors - lizard - spock ";
static char szTmp[] = " ";
static int len = sizeof(szText);
static int pos = 0;
int i;
#define INCREMENT_ARRAY(var, type) \
if (var && var->Length > 0) { \
var->Value.type##Array[0]++; \
for (i = 1; i < var->Length; i++) \
{ \
var->Value.type##Array[i] = var->Value.type##Array[i-1]+1; \
} \
}
*g_pDynBoolean = ! *g_pDynBoolean;
(*g_pDynSByte)++;
(*g_pDynByte) -= 3;
(*g_pDynInt16) += 21;
(*g_pDynUInt16) -= 53;
(*g_pDynInt32)++;
(*g_pDynUInt32)++;
(*g_pDynInt64) += 2376452644LL;
(*g_pDynUInt64) -= 987654321ULL;
(*g_pDynFloat) += 0.1f;
(*g_pDynDouble) += 0.1;
switch (*g_pDynStatusCode)
{
case OpcUa_Good:
*g_pDynStatusCode = OpcUa_Bad; break;
case OpcUa_Bad:
*g_pDynStatusCode = OpcUa_BadInvalidArgument; break;
case OpcUa_BadInvalidArgument:
*g_pDynStatusCode = OpcUa_GoodMoreData | OpcUa_StatusCode_InfoType_DataValue | OpcUa_StatusCode_InfoBit_Overflow; break;
case OpcUa_GoodMoreData | OpcUa_StatusCode_InfoType_DataValue | OpcUa_StatusCode_InfoBit_Overflow:
*g_pDynStatusCode = OpcUa_Good; break;
}
*g_pDynamicValue_Quality = *g_pDynStatusCode;
*g_pStaticValue_Quality = *g_pDynStatusCode;
if (++pos >= len-1) pos = 0;
OpcUa_StrlCpyA( szTmp, szText+pos, len-pos );
OpcUa_StrlCpyA( szTmp+len-pos-1, szText, pos+1 );
OpcUa_String_AttachReadOnly( g_pDynString, szTmp);
*g_pDynDateTime = OpcUa_DateTime_UtcNow();
OpcUa_Guid_Create( *g_ppDynGuid );
if (g_pDynByteString->Length <= 0)
{
g_pDynByteString->Length = 0;
if (g_pDynByteString->Data) OpcUa_Free(g_pDynByteString->Data);
g_pDynByteString->Data = OpcUa_Alloc(sizeof(szTmp));
if (g_pDynByteString->Data)
{
g_pDynByteString->Length = sizeof(szTmp);
}
}
if (g_pDynByteString->Data)
{
OpcUa_MemCpy(
g_pDynByteString->Data, g_pDynByteString->Length,
szTmp, sizeof(szTmp)
);
}
if (g_pDynXmlElement->Length <= 0)
{
g_pDynXmlElement->Length = 0;
if (g_pDynXmlElement->Data) OpcUa_Free(g_pDynXmlElement->Data);
g_pDynXmlElement->Data = OpcUa_Alloc(sizeof(szTmp));
if (g_pDynXmlElement->Data)
{
g_pDynXmlElement->Length = sizeof(szTmp);
}
}
if (g_pDynXmlElement->Data)
{
OpcUa_MemCpy(
g_pDynXmlElement->Data, g_pDynXmlElement->Length,
szTmp, sizeof(szTmp)
);
}
(*g_pDynamicValue) += 0.1;
OpcUa_String_AttachReadOnly( &(*g_ppDynLocalizedText)->Text, szTmp);
(*g_ppDynQualifiedName)->NamespaceIndex++;
OpcUa_String_AttachReadOnly( &(*g_ppDynQualifiedName)->Name, szTmp);
(*g_ppDynNodeId)->NamespaceIndex++;
OpcUa_String_AttachReadOnly( &(*g_ppDynNodeId)->Identifier.String, szTmp);
(*g_ppDynExpandedNodeId)->ServerIndex++;
(*g_ppDynExpandedNodeId)->NodeId.NamespaceIndex++;
OpcUa_String_AttachReadOnly( &(*g_ppDynExpandedNodeId)->NodeId.Identifier.String, szTmp);
if (g_pDynArrayBoolean && g_pDynArrayBoolean->Length > 0)
{
g_pDynArrayBoolean->Value.BooleanArray[0] = !g_pDynArrayBoolean->Value.BooleanArray[0];
for (i = 1; i < g_pDynArrayBoolean->Length; i++)
{
g_pDynArrayBoolean->Value.BooleanArray[i] = !g_pDynArrayBoolean->Value.BooleanArray[i-1];
}
}
INCREMENT_ARRAY(g_pDynArrayByte, Byte);
INCREMENT_ARRAY(g_pDynArraySByte, SByte);
INCREMENT_ARRAY(g_pDynArrayUInt16, UInt16);
INCREMENT_ARRAY(g_pDynArrayInt16, Int16);
INCREMENT_ARRAY(g_pDynArrayUInt32, UInt32);
INCREMENT_ARRAY(g_pDynArrayInt32, Int32);
INCREMENT_ARRAY(g_pDynArrayUInt64, UInt64);
INCREMENT_ARRAY(g_pDynArrayInt64, Int64);
INCREMENT_ARRAY(g_pDynArrayFloat, Float);
INCREMENT_ARRAY(g_pDynArrayDouble, Double);
INCREMENT_ARRAY(g_pDynArrayStatusCode, StatusCode);
if (g_pDynArrayGuid)
{
for (i = 0; i < g_pDynArrayGuid->Length; i++)
{
OpcUa_Guid_Create(&g_pDynArrayGuid->Value.GuidArray[i]);
}
}
if (g_pDynArrayDateTime)
{
for (i = 0; i < g_pDynArrayDateTime->Length; i++)
{
g_pDynArrayDateTime->Value.DateTimeArray[i] = OpcUa_DateTime_UtcNow();
}
}
if (g_pDynArrayString)
{
for (i = 0; i < g_pDynArrayString->Length; i++)
{
OpcUa_String_AttachReadOnly( &g_pDynArrayString->Value.StringArray[i], szTmp);
}
}
if (g_pDynArrayByteString)
{
for (i = 0; i < g_pDynArrayByteString->Length; i++)
{
if (g_pDynArrayByteString->Value.ByteStringArray[i].Length <= 0)
{
g_pDynArrayByteString->Value.ByteStringArray[i].Length = 0;
if (g_pDynArrayByteString->Value.ByteStringArray[i].Data) OpcUa_Free(g_pDynArrayByteString->Value.ByteStringArray[i].Data);
g_pDynArrayByteString->Value.ByteStringArray[i].Data = OpcUa_Alloc(sizeof(szTmp));
if (g_pDynArrayByteString->Value.ByteStringArray[i].Data)
{
g_pDynArrayByteString->Value.ByteStringArray[i].Length = sizeof(szTmp);
}
}
if (g_pDynArrayByteString->Value.ByteStringArray[i].Data)
{
OpcUa_MemCpy(
g_pDynArrayByteString->Value.ByteStringArray[i].Data, g_pDynArrayByteString->Value.ByteStringArray[i].Length,
szTmp, sizeof(szTmp));
}
}
}
if (g_pDynArrayXmlElement)
{
for (i = 0; i < g_pDynArrayXmlElement->Length; i++)
{
if (g_pDynArrayXmlElement->Value.XmlElementArray[i].Length <= 0)
{
g_pDynArrayXmlElement->Value.XmlElementArray[i].Length = 0;
if (g_pDynArrayXmlElement->Value.XmlElementArray[i].Data) OpcUa_Free(g_pDynArrayXmlElement->Value.XmlElementArray[i].Data);
g_pDynArrayXmlElement->Value.XmlElementArray[i].Data = OpcUa_Alloc(sizeof(szTmp));
if (g_pDynArrayXmlElement->Value.XmlElementArray[i].Data)
{
g_pDynArrayXmlElement->Value.XmlElementArray[i].Length = sizeof(szTmp);
}
}
if (g_pDynArrayXmlElement->Value.XmlElementArray[i].Data)
{
OpcUa_MemCpy(
g_pDynArrayXmlElement->Value.XmlElementArray[i].Data, g_pDynArrayXmlElement->Value.XmlElementArray[i].Length,
szTmp, sizeof(szTmp)
);
}
}
}
if (g_pDynArrayLocalizedText)
{
for (i = 0; i < g_pDynArrayLocalizedText->Length; i++)
{
OpcUa_String_AttachReadOnly( &g_pDynArrayLocalizedText->Value.LocalizedTextArray[i].Text, szTmp);
}
}
if (g_pDynArrayQualifiedName)
{
for (i = 0; i < g_pDynArrayQualifiedName->Length; i++)
{
g_pDynArrayQualifiedName->Value.QualifiedNameArray[i].NamespaceIndex++;
OpcUa_String_AttachReadOnly( &g_pDynArrayQualifiedName->Value.QualifiedNameArray[i].Name, szTmp);
}
}
if (g_pDynArrayNodeId)
{
for (i = 0; i < g_pDynArrayNodeId->Length; i++)
{
g_pDynArrayNodeId->Value.NodeIdArray[i].NamespaceIndex++;
OpcUa_String_AttachReadOnly( &g_pDynArrayNodeId->Value.NodeIdArray[i].Identifier.String, szTmp);
}
}
if (g_pDynArrayExpandedNodeId)
{
for (i = 0; i < g_pDynArrayExpandedNodeId->Length; i++)
{
g_pDynArrayExpandedNodeId->Value.ExpandedNodeIdArray[i].ServerIndex++;
g_pDynArrayExpandedNodeId->Value.ExpandedNodeIdArray[i].NodeId.NamespaceIndex++;
OpcUa_String_AttachReadOnly( &g_pDynArrayExpandedNodeId->Value.ExpandedNodeIdArray[i].NodeId.Identifier.String, szTmp);
}
}
}
#if UAPROVIDER_DEMO_HAVE_MASS_ITEMS
static void UaProvider_Demo_SimulateMassfolderDynamicVariables()
{
int i;
OpcUa_UInt32 val = *g_pMassDynUInt32[0]+1;
for (i=0; i<UAPROVIDER_DEMO_NUM_MASS_DYNAMIC_VARIABLES; i++)
{
*g_pMassDynUInt32[i] = val;
}
}
#endif
static void UaProvider_Demo_SimulateHistoryVariables()
{
static int t = 0;
static int mode = 1;
if (g_pHistoryByte) (*g_pHistoryByte) += (OpcUa_Byte)mode;
if (g_pHistoryDouble) (*g_pHistoryDouble) = 90 + 90 * sin(t*M_PI/180.0);
t++;
if ((t % 180) == 0) mode *= -1;
if (t == 360) t = 0;
}
static void UaProvider_Demo_SimulateBoiler( BoilerType *pBoiler )
{
double dtT;
double dtTDeadband = 2;
double C = 4187;
double dt = 10;
double P = 1.5;
double m;
double J = 1000 * P * dt;
if (pBoiler == 0) return;
if (pBoiler->pTemperature == 0) return;
if (pBoiler->pTemperatureSetPoint == 0) return;
if (pBoiler->pHeaterStatus == 0) return;
dtT = *pBoiler->pTemperature - *pBoiler->pTemperatureSetPoint;
m = *pBoiler->pFillLevel;
if ( dtT >= dtTDeadband )
{
*pBoiler->pHeaterStatus = Heater_Off;
}
else
{
*pBoiler->pHeaterStatus = Heater_Heating;
}
if ( *pBoiler->pHeaterStatus == Heater_Heating )
{
if (m > 0)
{
dtT =J / ( C * m );
*pBoiler->pTemperature += dtT;
}
}
else
{
dtT = *pBoiler->pTemperature - 20;
*pBoiler->pTemperature -= dtT / 100.0;
}
if ( *pBoiler->pFillLevel < *pBoiler->pFillLevelSetPoint )
{
(*pBoiler->pFillLevel)++;
}
else if ( *pBoiler->pFillLevel > *pBoiler->pFillLevelSetPoint )
{
(*pBoiler->pFillLevel)--;
}
}
#if UAPROVIDER_DEMO_HAVE_ANIMATION_ITEM && UABASE_USE_FILESYSTEM
static void UaProvider_Demo_SimulateAnimation()
{
static int frame_counter = 0;
char filename[200] = {0};
FILE *f;
OpcUa_SnPrintfA(filename, sizeof(filename), "animation/animation_%d.gif", frame_counter++);
f = fopen(filename, "rb");
if (f == OpcUa_Null)
{
frame_counter = 0;
OpcUa_SnPrintfA(filename, sizeof(filename), "animation/animation_%d.gif", frame_counter++);
f = fopen(filename, "rb");
}
if (f)
{
if (g_pAnimation->Length == 0 || g_pAnimation->Data == 0)
{
g_pAnimation->Data = OpcUa_Alloc(131072);
}
if (g_pAnimation->Data != 0)
{
g_pAnimation->Length = (OpcUa_Int32)fread(g_pAnimation->Data, 1, 131072, f);
}
fclose(f);
}
}
#endif
IFMETHODIMP(UaProvider_Demo_SimulationTimer)(
OpcUa_Void* a_pvCallbackData,
OpcUa_Timer a_hTimer,
OpcUa_UInt32 a_msecElapsed )
{
OpcUa_ReferenceParameter(a_pvCallbackData);
OpcUa_ReferenceParameter(a_hTimer);
OpcUa_ReferenceParameter(a_msecElapsed);
UaProvider_Demo_SimulateDynamicVariables();
UaProvider_Demo_SimulateHistoryVariables();
#if UAPROVIDER_DEMO_HAVE_MASS_ITEMS
UaProvider_Demo_SimulateMassfolderDynamicVariables();
#endif
UaProvider_Demo_SimulateBoiler(&g_Boiler1);
#if UASERVER_SUPPORT_EVENTS
UaProvider_Demo_SimulateMachine(&g_machine);
#endif
return OpcUa_Good;
}
#if UAPROVIDER_DEMO_HAVE_ANIMATION_ITEM && UABASE_USE_FILESYSTEM
IFMETHODIMP(UaProvider_Demo_AnimationTimer)(
OpcUa_Void* a_pvCallbackData,
OpcUa_Timer a_hTimer,
OpcUa_UInt32 a_msecElapsed)
{
OpcUa_ReferenceParameter(a_pvCallbackData);
OpcUa_ReferenceParameter(a_hTimer);
OpcUa_ReferenceParameter(a_msecElapsed);
UaProvider_Demo_SimulateAnimation();
return OpcUa_Good;
}
#endif
#if UASERVER_SUPPORT_EVENTS
OpcUa_StatusCode UaProvider_Demo_SendModelChangeEvent(OpcUa_BaseNode *pParent, OpcUa_Byte verb)
{
OpcUa_ByteString_Initialize(&bsEventId);
OpcUa_Variant_Initialize(&modelChanges);
OpcUa_NodeId_Initialize(&typeId);
typeId.Identifier.Numeric = OpcUaId_GeneralModelChangeEventType;
OpcUa_ByteString_Clear(&bsEventId);
modelChanges.
Datatype = OpcUaType_ExtensionObject;
modelChanges.
ArrayType = OpcUa_VariantArrayType_Array;
OpcUa_ReturnErrorIfAllocFailed(modelChanges.
Value.Array.Value.ExtensionObjectArray);
modelChanges.
Value.Array.Length = 1;
OpcUa_ExtensionObject_Initialize(&modelChanges.
Value.Array.Value.ExtensionObjectArray[0]);
ret = OpcUa_EncodeableObject_CreateExtension(&OpcUa_ModelChangeStructureDataType_EncodeableType,
&modelChanges.
Value.Array.Value.ExtensionObjectArray[0],
(OpcUa_Void**)&pModelChanges);
OpcUa_ReturnErrorIfBad(ret);
pModelChanges->
Verb = verb;
OpcUa_NodeId_CopyTo(pParentId, &pModelChanges->
Affected);
pModelChanges->
AffectedType.Identifier.Numeric = OpcUaId_FolderType;
OpcUa_Variant_Clear(&modelChanges);
return ret;
}
OpcUa_Void UaProvider_Demo_SimulateMachine(Machine *a_pMachine)
{
OpcUa_Boolean *pSwitch = a_pMachine->HeaterSwitch.pValue;
OpcUa_Double *pTemp = a_pMachine->TemperatureSensor.pValue;
OpcUa_Double oldTemperature = *pTemp;
if (*pSwitch == OpcUa_True && *pTemp < 110.0)
{
*pTemp += 0.5;
}
else if (*pSwitch == OpcUa_False && *pTemp > -10.0)
{
*pTemp -= 0.5;
}
if (oldTemperature < 100 && *pTemp >= 100)
{
g_UaProviderDemo_uNamespaceIndex1,
&a_pMachine->TemperatureSensor.HighAlarmId);
if (pHighAlarm)
UaProvider_Demo_FireAlarmConditionTypeEvent(pHighAlarm);
}
if (oldTemperature > 0 && *pTemp <= 0)
{
g_UaProviderDemo_uNamespaceIndex1,
&a_pMachine->TemperatureSensor.LowAlarmId);
if (pLowAlarm)
UaProvider_Demo_FireAlarmConditionTypeEvent(pLowAlarm);
}
if (oldTemperature >= 100 && *pTemp < 100)
{
g_UaProviderDemo_uNamespaceIndex1,
&a_pMachine->TemperatureSensor.HighAlarmId);
if (pHighAlarm)
UaProvider_Demo_DisableAlarmConditionTypeEvent(pHighAlarm);
}
if (oldTemperature <= 0 && *pTemp > 0)
{
g_UaProviderDemo_uNamespaceIndex1,
&a_pMachine->TemperatureSensor.LowAlarmId);
if (pLowAlarm)
UaProvider_Demo_DisableAlarmConditionTypeEvent(pLowAlarm);
}
}
#endif
{
Demo_WorkOrderType workOrder;
OpcUa_InitializeStatus(OpcUa_Module_Server, "UaProvider_Demo_GetUserDataValue");
OpcUa_ReturnErrorIfArgumentNull(a_pUserData);
OpcUa_ReturnErrorIfArgumentNull(a_pVariable);
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
Demo_WorkOrderType_Initialize(&workOrder);
switch (a_pUserData->Type)
{
case UserDataType_Quality:
{
QualityInformation *pQualityInformation = (QualityInformation*)a_pUserData;
a_pValue->
StatusCode = pQualityInformation->Quality;
{
OpcUa_GotoErrorIfBad(uStatus);
}
else
{
OpcUa_Variant_Clear(&a_pValue->
Value);
}
break;
}
case UserDataType_WorkOrderTypeReference:
{
WorkOrderTypeReference *pWorkOrderTypeReference = (WorkOrderTypeReference*)a_pUserData;
pWorkOrderTypeReference->pWorkOrderType->Value.ExtensionObject,
&workOrder);
OpcUa_GotoErrorIfBad(uStatus);
switch (pWorkOrderTypeReference->Field)
{
case WorkOrderTypeField_ID:
OpcUa_GotoErrorIfAllocFailed(a_pValue->
Value.
Value.Guid);
OpcUa_Guid_CopyTo(&workOrder.ID, a_pValue->
Value.
Value.Guid);
break;
case WorkOrderTypeField_AssetID:
uStatus = OpcUa_String_CopyTo(&workOrder.AssetID, &a_pValue->
Value.
Value.String);
OpcUa_GotoErrorIfBad(uStatus);
break;
case WorkOrderTypeField_StartTime:
a_pValue->
Value.
Value.DateTime = workOrder.StartTime;
break;
case WorkOrderTypeField_StatusComments:
uStatus = UaBase_Structures_To_Variant(&Demo_WorkOrderStatusType_EncodeableType,
g_UaProviderDemo_uNamespaceIndex1,
workOrder.NoOfStatusComments,
workOrder.StatusComments,
OpcUa_GotoErrorIfBad(uStatus);
break;
default:
break;
}
Demo_WorkOrderType_Clear(&workOrder);
break;
}
default:
break;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_WorkOrderType_Clear(&workOrder);
OpcUa_DataValue_Clear(a_pValue);
OpcUa_FinishErrorHandling;
}
{
Demo_WorkOrderType workOrder;
OpcUa_InitializeStatus(OpcUa_Module_Server, "UaProvider_Demo_SetUserDataValue");
OpcUa_ReturnErrorIfArgumentNull(a_pUserData);
OpcUa_ReturnErrorIfArgumentNull(a_pVariable);
OpcUa_ReturnErrorIfArgumentNull(a_pValue);
Demo_WorkOrderType_Initialize(&workOrder);
switch (a_pUserData->Type)
{
case UserDataType_WorkOrderTypeReference:
{
WorkOrderTypeReference *pWorkOrderTypeReference = (WorkOrderTypeReference*)a_pUserData;
pWorkOrderTypeReference->pWorkOrderType->Value.ExtensionObject,
&workOrder);
OpcUa_GotoErrorIfBad(uStatus);
switch (pWorkOrderTypeReference->Field)
{
case WorkOrderTypeField_ID:
if (a_pValue->
Datatype == OpcUaType_Guid &&
a_pValue->
ArrayType == OpcUa_VariantArrayType_Scalar &&
a_pValue->
Value.Guid != OpcUa_Null)
{
OpcUa_Guid_CopyTo(a_pValue->
Value.Guid, &workOrder.ID);
}
break;
case WorkOrderTypeField_AssetID:
if (a_pValue->
Datatype == OpcUaType_String &&
a_pValue->
ArrayType == OpcUa_VariantArrayType_Scalar)
{
uStatus = OpcUa_String_CopyTo(&a_pValue->
Value.String, &workOrder.AssetID);
OpcUa_GotoErrorIfBad(uStatus);
}
break;
case WorkOrderTypeField_StartTime:
if (a_pValue->
Datatype == OpcUaType_DateTime &&
a_pValue->
ArrayType == OpcUa_VariantArrayType_Scalar)
{
workOrder.StartTime = a_pValue->
Value.DateTime;
}
break;
case WorkOrderTypeField_StatusComments:
if (a_pValue->
Datatype == OpcUaType_ExtensionObject &&
a_pValue->
ArrayType == OpcUa_VariantArrayType_Array)
{
OpcUa_Int32 i;
for (i = 0; i < workOrder.NoOfStatusComments; i++)
{
Demo_WorkOrderStatusType_Clear(&workOrder.StatusComments[i]);
}
OpcUa_Free(workOrder.StatusComments);
workOrder.NoOfStatusComments = 0;
workOrder.StatusComments = OpcUa_Null;
uStatus = UaBase_Structures_From_ExtensionObjects(&Demo_WorkOrderStatusType_EncodeableType,
a_pValue->
Value.Array.Length,
a_pValue->
Value.Array.Value.ExtensionObjectArray,
&workOrder.NoOfStatusComments,
(OpcUa_Void**)&workOrder.StatusComments);
OpcUa_GotoErrorIfBad(uStatus);
}
break;
default:
break;
}
OpcUa_ExtensionObject_Clear(pWorkOrderTypeReference->pWorkOrderType->Value.ExtensionObject);
g_UaProviderDemo_uNamespaceIndex1,
&workOrder,
pWorkOrderTypeReference->pWorkOrderType->Value.ExtensionObject);
OpcUa_GotoErrorIfBad(uStatus);
Demo_WorkOrderType_Clear(&workOrder);
break;
}
default:
break;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
Demo_WorkOrderType_Clear(&workOrder);
OpcUa_FinishErrorHandling;
}
OPCUA_END_EXTERN_C