NotifyCallback uses a fixed datatype for processing. Can the code be adapted to handle different datatypes based on what was returned by device.ShowSymbols?

[jackybek]

in example/example.cpp, the function NotifyCallback initialised a variable data using
DataType data{};

DataType is defined earlier as : using DataType = uint8_t;

What happens if the variable is not a uint8_t?

I tried to adapt the code that uses different "using DataType = float" if the variable returned by ADS is a float.
But the compiler fails to compile.

My thinking is to handle different datatypes, i would have to do this:

using boolDataType = bool;
using uint8DataType = uint8_t;
using uint16DataType = uint16_t;
using uint32DataType = uint32_t;
using uint64DataType = uint64_t;
using doubleDataType = double;
using floatDataType = float;
using int8DataType = int8_t;
using int16DataType = int16_t;
using int32DataType = int32_t;
using int64DataType = int64_t;

notificationByName(std::ostream& out, const AdsDevice& route, std::string variableName, int variableType)
{
switch (variableType)
case UA_TYPES_FLOAT :
attrib = {
sizeof(float),
ADSTRANS_SERVERCYCLE,
0,
{4000000}
};
break;
case UA_TYPES_DOUBLE:
attrib = {
sizeof(double),
ADSTRANS_SERVERCYCLE,
0,
{4000000}
};
break;
}
out << FUNCTION << "():\n";
AdsNotification notification { route, variableName, attrib, &NotifyCallback, 0xBEEFDEAD };

::Question: can i pass in variableType using notification? I tried to add to attrib{} but it failed to compile. I then tried to call as a parameter to notification.. also fail to compile.

}

Then in
NotifyCallback(const AmsAddr* pAddr, const AdsNotificationHeader* pNotification, uint32_t hUser)
{
// check the variableType passed in from notification
// if I can get the variableType i will do the following:

if (variableType == uint8_t)
{
uint8DataType booldata{};
std::memcpy(&boolData, pNotification + 1, std::min<size_t>(sizeof(boolData), pNotification->cbSampleSize));
}
else if (variableType == uint16_t)
{
uint16DataType booldata{};
std::memcpy(&boolData, pNotification + 1, std::min<size_t>(sizeof(boolData), pNotification->cbSampleSize));
}
... < and so on for the other datatype>

[jackybek]

I put the function here for easy of reference:

void NotifyCallback(const AmsAddr* pAddr, const AdsNotificationHeader* pNotification, uint32_t hUser)
{
bool boolData{};
uint8_t uint8Data{};
uint16_t uint16Data{};
uint32_t uint32Data{};
uint64_t uint64Data{};
double doubleData{};
float floatData{};
int8_t int8Data{};
int16_t int16Data{};
int32_t int32Data{};
int64_t int64Data{};

if (variableType == uint8_t)
{
uint8DataType data{};
std::memcpy(&uint8Data, pNotification + 1, std::min<size_t>(sizeof(uint8Data), pNotification->cbSampleSize));

std::cout << std::setfill('0') <<
	"NetId: " << pAddr->netId <<
	" hUser 0x" << std::hex << hUser <<
	" time: " << std::dec << pNotification->nTimeStamp <<
	" size: " << std::dec << pNotification->cbSampleSize <<
	" value:" << " 0x" << std::hex << +data <<
	'\n';
}
else if (variableType == uint16_t)
{
uint16DataType data{};
std::memcpy(&uint16Data, pNotification + 1, std::min<size_t>(sizeof(uint16Data), pNotification->cbSampleSize));

    std::cout << std::setfill('0') <<
            "NetId: " << pAddr->netId <<
            " hUser 0x" << std::hex << hUser <<
            " time: " << std::dec << pNotification->nTimeStamp <<
            " size: " << std::dec << pNotification->cbSampleSize <<
            " value:" << " 0x" << std::hex << +data <<
            '\n';
}

// update OPCUA server based on the variable and value received in the callback

//OR
}

=====================

void notificationByName(std::ostream& out, const AdsDevice& route, std::string variableName, int variableType)
{
AdsNotificationAttrib attrib = {};
switch (variableType)
{
	case UA_TYPES_BOOLEAN :
                    attrib = {
                            sizeof(bool),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
                    break;

	case UA_TYPES_BYTE : // variableType = uint8_t;
		attrib = {
    			sizeof(uint8_t),
    			ADSTRANS_SERVERCYCLE,
    			0,
    			{4000000}
				};
		break;
	case UA_TYPES_UINT16 : // dataType = uint16_t;
		attrib = {
                            sizeof(uint16_t),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
		break;
	case UA_TYPES_UINT32 : // dataType = uint32_t;
		attrib = {
                            sizeof(uint32_t),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
		break;
	case UA_TYPES_UINT64 : // dataType = uint64_t;
		attrib = {
                            sizeof(uint64_t),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
		break;

	case UA_TYPES_INT16 :
                    attrib = {
                            sizeof(int16_t),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
                    break;

	case UA_TYPES_INT32 :
                    attrib = {
                            sizeof(int32_t),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
                    break;

	case UA_TYPES_INT64 :
                    attrib = {
                            sizeof(int64_t),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
                    break;

	case UA_TYPES_FLOAT :
                    attrib = {
                            sizeof(float),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
                    break;

	case UA_TYPES_DOUBLE :
                    attrib = {
                            sizeof(double),
                            ADSTRANS_SERVERCYCLE,
                            0,
                            {4000000}
                            };
                    break;

}

out << __FUNCTION__ << "():\n";
AdsNotification notification { route, variableName, attrib, &NotifyCallback, 0xBEEFDEAD };

}

Then somewhere in my main() program

{
// create a ADS notification callback
notificationByName(std::cout, route, _name, _variableType);
// where _name is the name of the variable declared in TwinCAT and read in via ADS
}

[jackybek]

This is the concept diagram.

[jackybek]

Can I check with you:

A. This function, the part highlighted in BOLD
static void notificationByNameExample(std::ostream& out, const AdsDevice& route)
{
const AdsNotificationAttrib attrib = {
sizeof(ExampleDatatype),
ADSTRANS_SERVERCYCLE,
0,
{4000000}
};

out << __FUNCTION__ << "():\n";
**AdsNotification notification { route, "MAIN.byByte[4]", attrib, &NotifyCallback, 0xBEEFDEAD };**

out << "Hit ENTER to stop by name notifications\n";
std::cin.ignore();

}

Questions:

1. Does it mean that when this variable (declared in TwinCAT) MAIN.byByte[4] is updated, NotifyCallback will be invoked?

2. What is the significance of 0xBEEFDEAD

3. If i want to be notified for 10 twincat variables, i need to do as follows ?

static void notificationByName_var1()
{
....
AdsNotification notification { route, var1, attrib, &NotifyCallback_var1, 0xBEEFDEAD };

}

static void NotifyCallback_var1(const AmsAddr* pAddr, const AdsNotificationHeader* pNotification, uint32_t hUser)
{
ExampleDatatype data{};
std::memcpy(&data, pNotification + 1, std::min<size_t>(sizeof(data), pNotification->cbSampleSize));
std::cout << std::setfill('0') <<
"NetId: " << pAddr->netId <<
" hUser 0x" << std::hex << hUser <<
" sample time: " << std::dec << pNotification->nTimeStamp <<
" sample size: " << std::dec << pNotification->cbSampleSize <<
" value:" << " 0x" << std::hex << +data <<
'\n';
}

Repeat for the other 9 variables.