public void ValidateMajorVersionEqMinorVersionEq(
[Values(DataSetFieldContentMask.None, DataSetFieldContentMask.RawData, // list here all possible DataSetFieldContentMask
DataSetFieldContentMask.ServerPicoSeconds, DataSetFieldContentMask.ServerTimestamp, DataSetFieldContentMask.SourcePicoSeconds,
DataSetFieldContentMask.SourceTimestamp, DataSetFieldContentMask.StatusCode,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.SourcePicoSeconds,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.SourceTimestamp,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.StatusCode,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp | DataSetFieldContentMask.SourcePicoSeconds,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp | DataSetFieldContentMask.SourceTimestamp,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp | DataSetFieldContentMask.StatusCode,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp | DataSetFieldContentMask.SourcePicoSeconds | DataSetFieldContentMask.SourceTimestamp,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp | DataSetFieldContentMask.SourcePicoSeconds | DataSetFieldContentMask.StatusCode,
DataSetFieldContentMask.ServerPicoSeconds | DataSetFieldContentMask.ServerTimestamp | DataSetFieldContentMask.SourcePicoSeconds | DataSetFieldContentMask.SourceTimestamp | DataSetFieldContentMask.StatusCode
)]
DataSetFieldContentMask dataSetFieldContentMask)
{
const int VersionValue = 2;
// Arrange
UadpDataSetMessage uadpDataSetMessage = GetFirstDataSetMessage(dataSetFieldContentMask);
// Act
uadpDataSetMessage.SetMessageContentMask(UadpDataSetMessageContentMask.MajorVersion | UadpDataSetMessageContentMask.MinorVersion);
uadpDataSetMessage.MetaDataVersion.MajorVersion = VersionValue;
uadpDataSetMessage.MetaDataVersion.MinorVersion = VersionValue * 10;
IServiceMessageContext messageContextEncode = new ServiceMessageContext();
byte[] bytes;
var memoryStream = new MemoryStream();
using (BinaryEncoder encoder = new BinaryEncoder(memoryStream, messageContextEncode, true))
{
uadpDataSetMessage.Encode(encoder);
_ = encoder.Close();
bytes = ReadBytes(memoryStream);
}
UadpDataSetMessage uaDataSetMessageDecoded = new UadpDataSetMessage();
BinaryDecoder decoder = new BinaryDecoder(bytes, messageContextEncode);
// Make sure the reader MajorVersion and MinorVersion are the same with the ones on the dataset message
DataSetReaderDataType reader = (DataSetReaderDataType)m_firstDataSetReaderType.MemberwiseClone();
reader.DataSetMetaData.ConfigurationVersion.MajorVersion = VersionValue;
reader.DataSetMetaData.ConfigurationVersion.MinorVersion = VersionValue * 10;
// workaround
uaDataSetMessageDecoded.DataSetWriterId = TestDataSetWriterId;
uaDataSetMessageDecoded.DecodePossibleDataSetReader(decoder, reader);
decoder.Dispose();
// Assert
Assert.AreEqual(DataSetDecodeErrorReason.NoError, uaDataSetMessageDecoded.DecodeErrorReason);
Assert.AreEqual(false, uaDataSetMessageDecoded.IsMetadataMajorVersionChange);
Assert.AreNotEqual(null, uaDataSetMessageDecoded.DataSet);
// compare uadpDataSetMessage with uaDataSetMessageDecoded
CompareUadpDataSetMessages(uadpDataSetMessage, uaDataSetMessageDecoded);
}
/// <summary>
/// Atempt to Decode dataset
/// </summary>
/// <returns></returns>
public void DecodePossibleDataSetReader(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
{
UadpDataSetReaderMessageDataType messageSettings = ExtensionObject.ToEncodeable(dataSetReader.MessageSettings)
as UadpDataSetReaderMessageDataType;
if (messageSettings != null)
{
//StartPositionInStream is calculated but different from reader configuration dataset cannot be decoded
if (StartPositionInStream != messageSettings.DataSetOffset)
{
if (StartPositionInStream == 0)
{
//use configured offset from reader
StartPositionInStream = messageSettings.DataSetOffset;
}
else if (messageSettings.DataSetOffset != 0)
{
//configuration is different from real position in message, the dataset cannot be decoded
return;
}
}
else
{
StartPositionInStream = (int)(binaryDecoder.BaseStream.Position);
}
}
if (binaryDecoder.BaseStream.Length <= StartPositionInStream)
{
return;
}
binaryDecoder.BaseStream.Position = StartPositionInStream;
DecodeDataSetMessageHeader(binaryDecoder);
DataSet = DecodeFieldMessageData(binaryDecoder, dataSetReader);
}
/// <summary>
/// Atempt to decode dataset from the Keyvalue pairs
/// </summary>
private void DecodePossibleDataSetReader(JsonDecoder jsonDecoder, DataSetReaderDataType dataSetReader)
{
// check if there shall be a dataset header and decode it
if (HasDataSetMessageHeader)
{
DecodeDataSetMessageHeader(jsonDecoder);
}
if (dataSetReader.DataSetWriterId != 0 && DataSetWriterId != dataSetReader.DataSetWriterId)
{
return;
}
object token = null;
string payloadStructureName = kFieldPayload;
// try to read "Payload" structure
if (!jsonDecoder.ReadField(kFieldPayload, out token))
{
// Decode the Messages element in case there is no "Payload" structure
jsonDecoder.ReadField(null, out token);
payloadStructureName = null;
}
Dictionary <string, object> payload = token as Dictionary <string, object>;
if (payload != null)
{
if (payload.Count > dataSetReader.DataSetMetaData.Fields.Count)
{
// filter out payload that has more fields than the searched datasetMetadata
return;
}
// check also the field names from reader, if any extra field names then the payload is not matching
foreach (string key in payload.Keys)
{
var field = dataSetReader.DataSetMetaData.Fields.FirstOrDefault(f => f.Name == key);
if (field == null)
{
// the field from payload was not found in dataSetReader therefore the payload is not suitable to be decoded
return;
}
}
}
try
{
// try decoding Payload Structure
bool wasPush = jsonDecoder.PushStructure(payloadStructureName);
if (wasPush)
{
DataSet = DecodePayloadContent(jsonDecoder, dataSetReader);
}
}
finally
{
// redo decode stack
jsonDecoder.Pop();
}
}
public void ValidateOperational_2ToDisabled_0_Reader()
{
UaPubSubApplication uaPubSubApplication = UaPubSubApplication.Create(SubscriberConfigurationFileName);
UaPubSubConfigurator configurator = uaPubSubApplication.UaPubSubConfigurator;
// The hierarchy PubSub -> PubSubConnection -> PubSubReaderGroup -> DataSetReader brought to [Disabled, Disabled, Disabled, Disabled]
PubSubConfigurationDataType pubSub = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration;
PubSubConnectionDataType subscriberConnection = uaPubSubApplication.UaPubSubConfigurator.PubSubConfiguration.Connections[0];
ReaderGroupDataType readerGroup = subscriberConnection.ReaderGroups[0];
DataSetReaderDataType datasetReader = readerGroup.DataSetReaders[0];
configurator.Disable(pubSub);
configurator.Disable(subscriberConnection);
configurator.Disable(readerGroup);
configurator.Disable(datasetReader);
PubSubState psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
PubSubState conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(subscriberConnection);
PubSubState rgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(readerGroup);
PubSubState dsrState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetReader);
Assert.That(psState == PubSubState.Disabled, Is.True);
Assert.That(conState == PubSubState.Disabled, Is.True);
Assert.That(rgState == PubSubState.Disabled, Is.True);
Assert.That(dsrState == PubSubState.Disabled, Is.True);
// The hierarchy PubSub -> PubSubConnection -> PubSubReaderGroup -> DataSetReader brought to [Operational, Operational, Operational, Operational]
configurator.Enable(pubSub);
configurator.Enable(subscriberConnection);
configurator.Enable(readerGroup);
configurator.Enable(datasetReader);
psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(subscriberConnection);
rgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(readerGroup);
dsrState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetReader);
Assert.That(psState == PubSubState.Operational, Is.True);
Assert.That(conState == PubSubState.Operational, Is.True);
Assert.That(rgState == PubSubState.Operational, Is.True);
Assert.That(dsrState == PubSubState.Operational, Is.True);
// The hierarchy PubSub -> PubSubConnection -> PubSubReaderGroup -> DataSetReader brought to [Disabled, Disabled, Disabled, Disabled]
configurator.Disable(pubSub);
configurator.Disable(subscriberConnection);
configurator.Disable(readerGroup);
configurator.Disable(datasetReader);
psState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(pubSub);
conState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(subscriberConnection);
rgState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(readerGroup);
dsrState = uaPubSubApplication.UaPubSubConfigurator.FindStateForObject(datasetReader);
Assert.That(psState == PubSubState.Disabled, Is.True);
Assert.That(conState == PubSubState.Disabled, Is.True);
Assert.That(rgState == PubSubState.Disabled, Is.True);
Assert.That(dsrState == PubSubState.Disabled, Is.True);
}
/// <summary>
/// Atempt to Decode dataset
/// </summary>
/// <returns></returns>
public void DecodePossibleDataSetReader(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
{
UadpDataSetReaderMessageDataType messageSettings = ExtensionObject.ToEncodeable(dataSetReader.MessageSettings)
as UadpDataSetReaderMessageDataType;
if (messageSettings != null)
{
//StartPositionInStream is calculated but different from reader configuration dataset cannot be decoded
if (StartPositionInStream != messageSettings.DataSetOffset)
{
if (StartPositionInStream == 0)
{
//use configured offset from reader
StartPositionInStream = messageSettings.DataSetOffset;
}
else if (messageSettings.DataSetOffset != 0)
{
//configuration is different from real position in message, the dataset cannot be decoded
return;
}
}
else
{
StartPositionInStream = (int)(binaryDecoder.BaseStream.Position);
}
}
if (binaryDecoder.BaseStream.Length <= StartPositionInStream)
{
return;
}
binaryDecoder.BaseStream.Position = StartPositionInStream;
DecodeDataSetMessageHeader(binaryDecoder);
DecodeErrorReason = ValidateMetadataVersion(dataSetReader.DataSetMetaData.ConfigurationVersion);
if (!IsMetadataMajorVersionChange)
{
if ((DataSetFlags2 & DataSetFlags2EncodingMask.DataDeltaFrame) == DataSetFlags2EncodingMask.DataDeltaFrame)
{
DataSet = DecodeMessageDataDeltaFrame(binaryDecoder, dataSetReader);
}
else
{
DataSet = DecodeMessageDataKeyFrame(binaryDecoder, dataSetReader);
}
}
}
public void MyTestInitialize()
{
// Create a publisher application
// todo refactor to use the MessagesHelper create configuration
string publisherConfigurationFile = Utils.GetAbsoluteFilePath(PublisherConfigurationFileName, true, true, false);
m_publisherApplication = UaPubSubApplication.Create(publisherConfigurationFile);
Assert.IsNotNull(m_publisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
m_publisherConfiguration = m_publisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_publisherConfiguration, "m_publisherConfiguration should not be null");
// Get first connection
Assert.IsNotNull(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be empty");
m_firstPublisherConnection = m_publisherApplication.PubSubConnections[0];
Assert.IsNotNull(m_firstPublisherConnection, "m_firstPublisherConnection should not be null");
// Read the first writer group
Assert.IsNotEmpty(m_publisherConfiguration.Connections[0].WriterGroups, "pubSubConfigConnection.WriterGroups should not be empty");
m_firstWriterGroup = m_publisherConfiguration.Connections[0].WriterGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstWriterGroup should not be null");
Assert.IsNotNull(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be empty");
// Create a subscriber application
string subscriberConfigurationFile = Utils.GetAbsoluteFilePath(SubscriberConfigurationFileName, true, true, false);
m_subscriberApplication = UaPubSubApplication.Create(subscriberConfigurationFile);
Assert.IsNotNull(m_subscriberApplication, "m_subscriberApplication should not be null");
// Get the subscriber configuration
m_subscriberConfiguration = m_subscriberApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_subscriberConfiguration, "m_subscriberConfiguration should not be null");
// Read the first reader group
m_firstReaderGroup = m_subscriberConfiguration.Connections[0].ReaderGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstReaderGroup should not be null");
m_firstDataSetReaderType = GetFirstDataSetReader();
}
public void MyTestInitialize()
{
// Create a publisher application
m_publisherApplication = UaPubSubApplication.Create(PublisherConfigurationFileName);
Assert.IsNotNull(m_publisherApplication, "m_publisherApplication should not be null");
// Get the publisher configuration
m_publisherConfiguration = m_publisherApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_publisherConfiguration, "m_publisherConfiguration should not be null");
// Get first connection
Assert.IsNotNull(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.Connections, "m_publisherConfiguration.Connections should not be empty");
m_firstPublisherConnection = m_publisherApplication.PubSubConnections[0];
Assert.IsNotNull(m_firstPublisherConnection, "m_firstPublisherConnection should not be null");
// Read the first writer group
Assert.IsNotEmpty(m_publisherConfiguration.Connections[0].WriterGroups, "pubSubConfigConnection.WriterGroups should not be empty");
m_firstWriterGroup = m_publisherConfiguration.Connections[0].WriterGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstWriterGroup should not be null");
Assert.IsNotNull(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be null");
Assert.IsNotEmpty(m_publisherConfiguration.PublishedDataSets, "m_publisherConfiguration.PublishedDataSets should not be empty");
// Create a subscriber application
m_subscriberApplication = UaPubSubApplication.Create(SubscriberConfigurationFileName);
Assert.IsNotNull(m_subscriberApplication, "m_subscriberApplication should not be null");
// Get the subscriber configuration
m_subscriberConfiguration = m_subscriberApplication.UaPubSubConfigurator.PubSubConfiguration;
Assert.IsNotNull(m_subscriberConfiguration, "m_subscriberConfiguration should not be null");
// Read the first reader group
m_firstReaderGroup = m_subscriberConfiguration.Connections[0].ReaderGroups[0];
Assert.IsNotNull(m_firstWriterGroup, "m_firstReaderGroup should not be null");
m_firstDataSetReaderType = GetFirstDataSetReader();
}
/// <summary>
/// Decode the Content of the Payload and create a DataSet object from it
/// </summary>
private DataSet DecodePayloadContent(JsonDecoder jsonDecoder, DataSetReaderDataType dataSetReader)
{
TargetVariablesDataType targetVariablesData =
ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet) as TargetVariablesDataType;
DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;
object token;
List <DataValue> dataValues = new List <DataValue>();
for (int index = 0; index < dataSetMetaData?.Fields.Count; index++)
{
FieldMetaData fieldMetaData = dataSetMetaData?.Fields[index];
if (jsonDecoder.ReadField(fieldMetaData.Name, out token))
{
switch (m_fieldTypeEncoding)
{
case FieldTypeEncodingMask.Variant:
Variant variantValue = jsonDecoder.ReadVariant(fieldMetaData.Name);
dataValues.Add(new DataValue(variantValue));
break;
case FieldTypeEncodingMask.RawData:
object value = DecodeRawData(jsonDecoder, dataSetMetaData?.Fields[index], dataSetMetaData?.Fields[index].Name);
dataValues.Add(new DataValue(new Variant(value)));
break;
case FieldTypeEncodingMask.DataValue:
bool wasPush2 = jsonDecoder.PushStructure(fieldMetaData.Name);
DataValue dataValue = new DataValue(Variant.Null);
try
{
if (wasPush2 && jsonDecoder.ReadField("Value", out token))
{
// the Value was encoded using the non reversible json encoding
token = DecodeRawData(jsonDecoder, dataSetMetaData?.Fields[index], "Value");
dataValue = new DataValue(new Variant(token));
}
else
{
// handle Good StatusCode that was not encoded
if (dataSetMetaData?.Fields[index].BuiltInType == (byte)BuiltInType.StatusCode)
{
dataValue = new DataValue(new Variant(new StatusCode(StatusCodes.Good)));
}
}
if ((FieldContentMask & DataSetFieldContentMask.StatusCode) != 0)
{
if (jsonDecoder.ReadField("StatusCode", out token))
{
bool wasPush3 = jsonDecoder.PushStructure("StatusCode");
if (wasPush3)
{
dataValue.StatusCode = jsonDecoder.ReadStatusCode("Code");
jsonDecoder.Pop();
}
}
}
if ((FieldContentMask & DataSetFieldContentMask.SourceTimestamp) != 0)
{
dataValue.SourceTimestamp = jsonDecoder.ReadDateTime("SourceTimestamp");
}
if ((FieldContentMask & DataSetFieldContentMask.SourcePicoSeconds) != 0)
{
dataValue.SourcePicoseconds = jsonDecoder.ReadUInt16("SourcePicoseconds");
}
if ((FieldContentMask & DataSetFieldContentMask.ServerTimestamp) != 0)
{
dataValue.ServerTimestamp = jsonDecoder.ReadDateTime("ServerTimestamp");
}
if ((FieldContentMask & DataSetFieldContentMask.ServerPicoSeconds) != 0)
{
dataValue.ServerPicoseconds = jsonDecoder.ReadUInt16("ServerPicoseconds");
}
dataValues.Add(dataValue);
}
finally
{
if (wasPush2)
{
jsonDecoder.Pop();
}
}
break;
}
}
else
{
switch (m_fieldTypeEncoding)
{
case FieldTypeEncodingMask.Variant:
case FieldTypeEncodingMask.RawData:
// handle StatusCodes.Good which is not encoded and therefore must be created at decode
if (dataSetMetaData?.Fields[index].BuiltInType == (byte)BuiltInType.StatusCode)
{
dataValues.Add(new DataValue(new Variant(new StatusCode(StatusCodes.Good))));
}
else
{
// the field is null
dataValues.Add(new DataValue(Variant.Null));
}
break;
}
}
}
if (dataValues.Count != dataSetMetaData?.Fields.Count)
{
return(null);
}
//build the DataSet Fields collection based on the decoded values and the target
List <Field> dataFields = new List <Field>();
for (int i = 0; i < dataValues.Count; i++)
{
Field dataField = new Field();
dataField.FieldMetaData = dataSetMetaData?.Fields[i];
dataField.Value = dataValues[i];
if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
i < targetVariablesData.TargetVariables.Count)
{
// remember the target Attribute and target nodeId
dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
dataField.TargetNodeId = targetVariablesData.TargetVariables[i].TargetNodeId;
}
dataFields.Add(dataField);
}
// build the dataset object
DataSet dataSet = new DataSet(dataSetMetaData?.Name);
dataSet.Fields = dataFields.ToArray();
dataSet.DataSetWriterId = DataSetWriterId;
dataSet.SequenceNumber = SequenceNumber;
return(dataSet);
}
/// <summary>
/// Decode dataset from the provided json decoder using the provided <see cref="DataSetReaderDataType"/>.
/// </summary>
/// <param name="jsonDecoder">The json decoder trhat contains the json stream.</param>
/// <param name="messagesCount">Number of Messages found in current jsonDecoder. If 0 then there is SingleDataSetMessage</param>
/// <param name="messagesListName">The name of the Messages list</param>
/// <param name="dataSetReader">The <see cref="DataSetReaderDataType"/> used to decode the data set.</param>
public void DecodePossibleDataSetReader(JsonDecoder jsonDecoder, int messagesCount, string messagesListName, DataSetReaderDataType dataSetReader)
{
if (messagesCount == 0)
{
// check if there shall be a dataset header and decode it
if (HasDataSetMessageHeader)
{
DecodeDataSetMessageHeader(jsonDecoder);
// push into PayloadStructure if there was a dataset header
jsonDecoder.PushStructure(kFieldPayload);
}
// handle single dataset with no network message header & no dataset message header (the content of the payload)
DataSet = DecodePayloadContent(jsonDecoder, dataSetReader);
}
else
{
for (int index = 0; index < messagesCount; index++)
{
bool wasPush = jsonDecoder.PushArray(messagesListName, index);
if (wasPush)
{
// atempt decoding the DataSet fields
DecodePossibleDataSetReader(jsonDecoder, dataSetReader);
// redo jsonDecoder stack
jsonDecoder.Pop();
if (DataSet != null)
{
// the dataset was decoded
return;
}
}
}
}
}
/// <summary>
/// Creates a PubSubConfiguration object programmatically.
/// </summary>
/// <returns></returns>
public static PubSubConfigurationDataType CreateSubscriberConfiguration()
{
// Define a PubSub connection with PublisherId 100
PubSubConnectionDataType pubSubConnection1 = new PubSubConnectionDataType();
pubSubConnection1.Name = "UADPConnection1";
pubSubConnection1.Enabled = true;
pubSubConnection1.PublisherId = (UInt16)100;
pubSubConnection1.TransportProfileUri = Profiles.UadpTransport;
NetworkAddressUrlDataType address = new NetworkAddressUrlDataType();
// Specify the local Network interface name to be used
// e.g. address.NetworkInterface = "Ethernet";
// Leave empty to subscribe on all available local interfaces.
address.NetworkInterface = String.Empty;
address.Url = "opc.udp://239.0.0.1:4840";
pubSubConnection1.Address = new ExtensionObject(address);
#region Define 'Simple' MetaData
DataSetMetaDataType simpleMetaData = new DataSetMetaDataType();
simpleMetaData.DataSetClassId = new Uuid(Guid.Empty);
simpleMetaData.Name = "Simple";
simpleMetaData.Fields = new FieldMetaDataCollection()
{
new FieldMetaData()
{
Name = "BoolToggle",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Boolean,
DataType = DataTypeIds.Boolean,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int32",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int32,
DataType = DataTypeIds.Int32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int32Fast",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int32,
DataType = DataTypeIds.Int32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "DateTime",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.DateTime,
DataType = DataTypeIds.DateTime,
ValueRank = ValueRanks.Scalar
},
};
simpleMetaData.ConfigurationVersion = new ConfigurationVersionDataType()
{
MinorVersion = 1,
MajorVersion = 1
};
#endregion
#region Define 'AllTypes' Metadata
DataSetMetaDataType allTypesMetaData = new DataSetMetaDataType();
allTypesMetaData.DataSetClassId = new Uuid(Guid.Empty);
allTypesMetaData.Name = "AllTypes";
allTypesMetaData.Fields = new FieldMetaDataCollection()
{
new FieldMetaData()
{
Name = "BoolToggle",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Boolean,
DataType = DataTypeIds.Boolean,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Byte",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Byte,
DataType = DataTypeIds.Byte,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int16",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int16,
DataType = DataTypeIds.Int16,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Int32",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Int32,
DataType = DataTypeIds.Int32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "SByte",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.SByte,
DataType = DataTypeIds.SByte,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "UInt16",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.UInt16,
DataType = DataTypeIds.UInt16,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "UInt32",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.UInt32,
DataType = DataTypeIds.UInt32,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Float",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Float,
DataType = DataTypeIds.Float,
ValueRank = ValueRanks.Scalar
},
new FieldMetaData()
{
Name = "Double",
DataSetFieldId = new Uuid(Guid.NewGuid()),
BuiltInType = (byte)DataTypes.Double,
DataType = DataTypeIds.Double,
ValueRank = ValueRanks.Scalar
},
};
allTypesMetaData.ConfigurationVersion = new ConfigurationVersionDataType()
{
MinorVersion = 1,
MajorVersion = 1
};
#endregion
#region Define ReaderGroup1
ReaderGroupDataType readerGroup1 = new ReaderGroupDataType();
readerGroup1.Name = "ReaderGroup 1";
readerGroup1.Enabled = true;
readerGroup1.MaxNetworkMessageSize = 1500;
readerGroup1.MessageSettings = new ExtensionObject(new ReaderGroupMessageDataType());
readerGroup1.TransportSettings = new ExtensionObject(new ReaderGroupTransportDataType());
#region Define DataSetReader 'Simple' for PublisherId = (UInt16)100, DataSetWriterId = 1
DataSetReaderDataType dataSetReaderSimple = new DataSetReaderDataType();
dataSetReaderSimple.Name = "Reader 1";
dataSetReaderSimple.PublisherId = (UInt16)100;
dataSetReaderSimple.WriterGroupId = 0;
dataSetReaderSimple.DataSetWriterId = 0;
dataSetReaderSimple.Enabled = true;
dataSetReaderSimple.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderSimple.KeyFrameCount = 1;
dataSetReaderSimple.DataSetMetaData = simpleMetaData;
UadpDataSetReaderMessageDataType uadpDataSetReaderMessage = new UadpDataSetReaderMessageDataType()
{
GroupVersion = 0,
DataSetOffset = 15,
NetworkMessageNumber = 0,
NetworkMessageContentMask = (uint)(uint)(UadpNetworkMessageContentMask.PublisherId | UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId | UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber | UadpNetworkMessageContentMask.SequenceNumber),
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetReaderSimple.MessageSettings = new ExtensionObject(uadpDataSetReaderMessage);
TargetVariablesDataType subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in simpleMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexSimple),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderSimple.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderSimple);
#region Define DataSetReader 'AllTypes' for PublisherId = (UInt16)100, DataSetWriterId = 2
DataSetReaderDataType dataSetReaderAllTypes = new DataSetReaderDataType();
dataSetReaderAllTypes.Name = "Reader 2";
dataSetReaderAllTypes.PublisherId = (UInt16)100;
dataSetReaderAllTypes.WriterGroupId = 0;
dataSetReaderAllTypes.DataSetWriterId = 0;
dataSetReaderAllTypes.Enabled = true;
dataSetReaderAllTypes.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderAllTypes.KeyFrameCount = 1;
dataSetReaderAllTypes.DataSetMetaData = allTypesMetaData;
uadpDataSetReaderMessage = new UadpDataSetReaderMessageDataType()
{
GroupVersion = 0,
DataSetOffset = 47,
NetworkMessageNumber = 0,
NetworkMessageContentMask = (uint)(uint)(UadpNetworkMessageContentMask.PublisherId | UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId | UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber | UadpNetworkMessageContentMask.SequenceNumber),
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetReaderAllTypes.MessageSettings = new ExtensionObject(uadpDataSetReaderMessage);
subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in allTypesMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexAllTypes),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderAllTypes.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderAllTypes);
#endregion
pubSubConnection1.ReaderGroups.Add(readerGroup1);
//create pub sub configuration root object
PubSubConfigurationDataType pubSubConfiguration = new PubSubConfigurationDataType();
pubSubConfiguration.Connections = new PubSubConnectionDataTypeCollection()
{
pubSubConnection1
};
return(pubSubConfiguration);
}
/// <summary>
/// Decode field message data delta frame from decoder and using a DataSetReader
/// </summary>
/// <param name="binaryDecoder"></param>
/// <param name="dataSetReader"></param>
/// <returns></returns>
private DataSet DecodeMessageDataDeltaFrame(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
{
DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;
try
{
FieldTypeEncodingMask fieldType = (FieldTypeEncodingMask)(((byte)DataSetFlags1 & kFieldTypeUsedBits) >> 1);
if (dataSetMetaData != null)
{
TargetVariablesDataType targetVariablesData =
ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet) as TargetVariablesDataType;
// create dataFields collection
List <Field> dataFields = new List <Field>();
for (int i = 0; i < dataSetMetaData.Fields.Count; i++)
{
Field dataField = new Field();
dataField.FieldMetaData = dataSetMetaData?.Fields[i];
if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
i < targetVariablesData.TargetVariables.Count)
{
// remember the target Attribute and target nodeId
dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
dataField.TargetNodeId = targetVariablesData.TargetVariables[i].TargetNodeId;
}
dataFields.Add(dataField);
}
// read number of fields encoded in this delta frame message
ushort fieldCount = fieldCount = binaryDecoder.ReadUInt16("FieldCount");
for (int i = 0; i < fieldCount; i++)
{
ushort fieldIndex = binaryDecoder.ReadUInt16("FieldIndex");
// update value in dataFields
switch (fieldType)
{
case FieldTypeEncodingMask.Variant:
dataFields[fieldIndex].Value = new DataValue(binaryDecoder.ReadVariant("FieldValue"));
break;
case FieldTypeEncodingMask.DataValue:
dataFields[fieldIndex].Value = binaryDecoder.ReadDataValue("FieldValue");
break;
case FieldTypeEncodingMask.RawData:
FieldMetaData fieldMetaData = dataSetMetaData.Fields[fieldIndex];
if (fieldMetaData != null)
{
var decodedValue = DecodeRawData(binaryDecoder, fieldMetaData);
dataFields[fieldIndex].Value = new DataValue(new Variant(decodedValue));
}
break;
case FieldTypeEncodingMask.Reserved:
// ignore
break;
}
}
DataSet dataSet = new DataSet(dataSetMetaData?.Name);
dataSet.DataSetMetaData = dataSetMetaData;
dataSet.Fields = dataFields.ToArray();
dataSet.IsDeltaFrame = true;
dataSet.DataSetWriterId = DataSetWriterId;
dataSet.SequenceNumber = SequenceNumber;
return(dataSet);
}
}
catch (Exception ex)
{
Utils.Trace(ex, "UadpDataSetMessage.DecodeMessageDataDeltaFrame");
}
return(null);
}
/// <summary>
/// Decode field message data key frame from decoder and using a DataSetReader
/// </summary>
/// <param name="binaryDecoder"></param>
/// <param name="dataSetReader"></param>
/// <returns></returns>
private DataSet DecodeMessageDataKeyFrame(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
{
DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;
try
{
ushort fieldCount = 0;
FieldTypeEncodingMask fieldType = (FieldTypeEncodingMask)(((byte)DataSetFlags1 & kFieldTypeUsedBits) >> 1);
if (fieldType == FieldTypeEncodingMask.RawData)
{
if (dataSetMetaData != null)
{
// metadata should provide field count
fieldCount = (ushort)dataSetMetaData.Fields.Count;
}
}
else
{
fieldCount = binaryDecoder.ReadUInt16("DataSetFieldCount");
}
TargetVariablesDataType targetVariablesData =
ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet) as TargetVariablesDataType;
// check configuration version
List <DataValue> dataValues = new List <DataValue>();
switch (fieldType)
{
case FieldTypeEncodingMask.Variant:
for (int i = 0; i < fieldCount; i++)
{
dataValues.Add(new DataValue(binaryDecoder.ReadVariant("Variant")));
}
break;
case FieldTypeEncodingMask.DataValue:
for (int i = 0; i < fieldCount; i++)
{
dataValues.Add(binaryDecoder.ReadDataValue("DataValue"));
}
break;
case FieldTypeEncodingMask.RawData:
if (dataSetMetaData != null)
{
for (int i = 0; i < fieldCount; i++)
{
FieldMetaData fieldMetaData = dataSetMetaData.Fields[i];
if (fieldMetaData != null)
{
var decodedValue = DecodeRawData(binaryDecoder, fieldMetaData);
dataValues.Add(new DataValue(new Variant(decodedValue)));
}
}
}
// else the decoding is compromised for RawData type
break;
case FieldTypeEncodingMask.Reserved:
// ignore
break;
}
List <Field> dataFields = new List <Field>();
for (int i = 0; i < dataValues.Count; i++)
{
Field dataField = new Field();
dataField.FieldMetaData = dataSetMetaData?.Fields[i];
dataField.Value = dataValues[i];
if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
i < targetVariablesData.TargetVariables.Count)
{
// remember the target Attribute and target nodeId
dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
dataField.TargetNodeId = targetVariablesData.TargetVariables[i].TargetNodeId;
}
dataFields.Add(dataField);
}
if (dataFields.Count == 0)
{
return(null); //the dataset cannot be decoded
}
DataSet dataSet = new DataSet(dataSetMetaData?.Name);
dataSet.DataSetMetaData = dataSetMetaData;
dataSet.Fields = dataFields.ToArray();
dataSet.DataSetWriterId = DataSetWriterId;
dataSet.SequenceNumber = SequenceNumber;
return(dataSet);
}
catch (Exception ex)
{
Utils.Trace(ex, "UadpDataSetMessage.DecodeMessageDataKeyFrame");
return(null);
}
}
/// <summary>
/// Creates a Subscriber PubSubConfiguration object for UDP & UADP programmatically.
/// </summary>
/// <returns></returns>
private static PubSubConfigurationDataType CreateSubscriberConfiguration_MqttUadp(string urlAddress)
{
// Define a PubSub connection with PublisherId 3
PubSubConnectionDataType pubSubConnection1 = new PubSubConnectionDataType();
pubSubConnection1.Name = "Subscriber Connection MQTT UADP";
pubSubConnection1.Enabled = true;
pubSubConnection1.PublisherId = (UInt16)3;
pubSubConnection1.TransportProfileUri = Profiles.PubSubMqttUadpTransport;
NetworkAddressUrlDataType address = new NetworkAddressUrlDataType();
// Specify the local Network interface name to be used
// e.g. address.NetworkInterface = "Ethernet";
// Leave empty to subscribe on all available local interfaces.
address.NetworkInterface = String.Empty;
address.Url = urlAddress;
pubSubConnection1.Address = new ExtensionObject(address);
// Configure the mqtt specific configuration with the MQTTbroker
ITransportProtocolConfiguration mqttConfiguration = new MqttClientProtocolConfiguration(version: EnumMqttProtocolVersion.V500);
pubSubConnection1.ConnectionProperties = mqttConfiguration.ConnectionProperties;
string brokerQueueName = "Uadp_WriterGroup_1";
string brokerMetaData = "$Metadata";
#region Define ReaderGroup1
ReaderGroupDataType readerGroup1 = new ReaderGroupDataType();
readerGroup1.Name = "ReaderGroup 1";
readerGroup1.Enabled = true;
readerGroup1.MaxNetworkMessageSize = 1500;
readerGroup1.MessageSettings = new ExtensionObject(new ReaderGroupMessageDataType());
readerGroup1.TransportSettings = new ExtensionObject(new ReaderGroupTransportDataType());
#region Define DataSetReader 'Simple' for PublisherId = (UInt16)1, DataSetWriterId = 1
DataSetReaderDataType dataSetReaderSimple = new DataSetReaderDataType();
dataSetReaderSimple.Name = "Reader 1 MQTT UADP";
dataSetReaderSimple.PublisherId = (UInt16)3;
dataSetReaderSimple.WriterGroupId = 0;
dataSetReaderSimple.DataSetWriterId = 1;
dataSetReaderSimple.Enabled = true;
dataSetReaderSimple.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderSimple.KeyFrameCount = 1;
BrokerDataSetReaderTransportDataType brokerTransportSettings = new BrokerDataSetReaderTransportDataType()
{
QueueName = brokerQueueName,
MetaDataQueueName = $"{brokerQueueName}/{brokerMetaData}",
};
dataSetReaderSimple.TransportSettings = new ExtensionObject(brokerTransportSettings);
UadpDataSetReaderMessageDataType uadpDataSetReaderMessage = new UadpDataSetReaderMessageDataType()
{
GroupVersion = 0,
NetworkMessageNumber = 0,
NetworkMessageContentMask = (uint)(uint)(UadpNetworkMessageContentMask.PublisherId
| UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId
| UadpNetworkMessageContentMask.PayloadHeader
| UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber
| UadpNetworkMessageContentMask.SequenceNumber),
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetReaderSimple.MessageSettings = new ExtensionObject(uadpDataSetReaderMessage);
// Create and set DataSetMetaData for DataSet Simple
DataSetMetaDataType simpleMetaData = CreateDataSetMetaDataSimple();
dataSetReaderSimple.DataSetMetaData = simpleMetaData;
// Create and set SubscribedDataSet
TargetVariablesDataType subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in simpleMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexSimple),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderSimple.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderSimple);
#region Define DataSetReader 'AllTypes' for PublisherId = (UInt16)1, DataSetWriterId = 2
DataSetReaderDataType dataSetReaderAllTypes = new DataSetReaderDataType();
dataSetReaderAllTypes.Name = "Reader 2 MQTT UADP";
dataSetReaderAllTypes.PublisherId = (UInt16)3;
dataSetReaderAllTypes.WriterGroupId = 0;
dataSetReaderAllTypes.DataSetWriterId = 2;
dataSetReaderAllTypes.Enabled = true;
dataSetReaderAllTypes.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderAllTypes.KeyFrameCount = 1;
dataSetReaderAllTypes.TransportSettings = new ExtensionObject(brokerTransportSettings);
uadpDataSetReaderMessage = new UadpDataSetReaderMessageDataType()
{
GroupVersion = 0,
NetworkMessageNumber = 0,
NetworkMessageContentMask = (uint)(uint)(UadpNetworkMessageContentMask.PublisherId
| UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId
| UadpNetworkMessageContentMask.PayloadHeader
| UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber
| UadpNetworkMessageContentMask.SequenceNumber),
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetReaderAllTypes.MessageSettings = new ExtensionObject(uadpDataSetReaderMessage);
// Create and set DataSetMetaData for DataSet AllTypes
DataSetMetaDataType allTypesMetaData = CreateDataSetMetaDataAllTypes();
dataSetReaderAllTypes.DataSetMetaData = allTypesMetaData;
// Create and set SubscribedDataSet
subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in allTypesMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexAllTypes),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderAllTypes.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderAllTypes);
#endregion
pubSubConnection1.ReaderGroups.Add(readerGroup1);
//create pub sub configuration root object
PubSubConfigurationDataType pubSubConfiguration = new PubSubConfigurationDataType();
pubSubConfiguration.Connections = new PubSubConnectionDataTypeCollection()
{
pubSubConnection1
};
return(pubSubConfiguration);
}
/// <summary>
/// Creates a Subscriber PubSubConfiguration object for UDP & UADP programmatically.
/// </summary>
/// <returns></returns>
private static PubSubConfigurationDataType CreateSubscriberConfiguration_UdpUadp(string urlAddress)
{
// Define a PubSub connection with PublisherId 1
PubSubConnectionDataType pubSubConnection1 = new PubSubConnectionDataType();
pubSubConnection1.Name = "Subscriber Connection UDP UADP";
pubSubConnection1.Enabled = true;
pubSubConnection1.PublisherId = (UInt16)1;
pubSubConnection1.TransportProfileUri = Profiles.PubSubUdpUadpTransport;
NetworkAddressUrlDataType address = new NetworkAddressUrlDataType();
// Specify the local Network interface name to be used
// e.g. address.NetworkInterface = "Ethernet";
// Leave empty to subscribe on all available local interfaces.
address.NetworkInterface = String.Empty;
address.Url = urlAddress;
pubSubConnection1.Address = new ExtensionObject(address);
// configure custoom DicoveryAddress for Dicovery messages
pubSubConnection1.TransportSettings = new ExtensionObject()
{
Body = new DatagramConnectionTransportDataType()
{
DiscoveryAddress = new ExtensionObject()
{
Body = new NetworkAddressUrlDataType()
{
Url = "opc.udp://224.0.2.15:4840"
}
}
}
};
#region Define ReaderGroup1
ReaderGroupDataType readerGroup1 = new ReaderGroupDataType();
readerGroup1.Name = "ReaderGroup 1";
readerGroup1.Enabled = true;
readerGroup1.MaxNetworkMessageSize = 1500;
readerGroup1.MessageSettings = new ExtensionObject(new ReaderGroupMessageDataType());
readerGroup1.TransportSettings = new ExtensionObject(new ReaderGroupTransportDataType());
#region Define DataSetReader 'Simple' for PublisherId = (UInt16)1, DataSetWriterId = 1
DataSetReaderDataType dataSetReaderSimple = new DataSetReaderDataType();
dataSetReaderSimple.Name = "Reader 1 UDP UADP";
dataSetReaderSimple.PublisherId = (UInt16)1;
dataSetReaderSimple.WriterGroupId = 0;
dataSetReaderSimple.DataSetWriterId = 1;
dataSetReaderSimple.Enabled = true;
dataSetReaderSimple.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderSimple.KeyFrameCount = 1;
dataSetReaderSimple.TransportSettings = new ExtensionObject(new DataSetReaderTransportDataType());
UadpDataSetReaderMessageDataType uadpDataSetReaderMessage = new UadpDataSetReaderMessageDataType()
{
GroupVersion = 0,
NetworkMessageNumber = 0,
NetworkMessageContentMask = (uint)(uint)(UadpNetworkMessageContentMask.PublisherId
| UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId
| UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber
| UadpNetworkMessageContentMask.SequenceNumber),
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetReaderSimple.MessageSettings = new ExtensionObject(uadpDataSetReaderMessage);
// Create and set DataSetMetaData for DataSet Simple
DataSetMetaDataType simpleMetaData = CreateDataSetMetaDataSimple();
dataSetReaderSimple.DataSetMetaData = simpleMetaData;
// Create and set SubscribedDataSet
TargetVariablesDataType subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in simpleMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexSimple),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderSimple.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderSimple);
#region Define DataSetReader 'AllTypes' for PublisherId = (UInt16)1, DataSetWriterId = 2
DataSetReaderDataType dataSetReaderAllTypes = new DataSetReaderDataType();
dataSetReaderAllTypes.Name = "Reader 2 UDP UADP";
dataSetReaderAllTypes.PublisherId = (UInt16)1;
dataSetReaderAllTypes.WriterGroupId = 0;
dataSetReaderAllTypes.DataSetWriterId = 2;
dataSetReaderAllTypes.Enabled = true;
dataSetReaderAllTypes.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderAllTypes.KeyFrameCount = 1;
dataSetReaderAllTypes.TransportSettings = new ExtensionObject(new DataSetReaderTransportDataType());
uadpDataSetReaderMessage = new UadpDataSetReaderMessageDataType()
{
GroupVersion = 0,
NetworkMessageNumber = 0,
NetworkMessageContentMask = (uint)(uint)(UadpNetworkMessageContentMask.PublisherId
| UadpNetworkMessageContentMask.GroupHeader
| UadpNetworkMessageContentMask.WriterGroupId
| UadpNetworkMessageContentMask.GroupVersion
| UadpNetworkMessageContentMask.NetworkMessageNumber
| UadpNetworkMessageContentMask.SequenceNumber),
DataSetMessageContentMask = (uint)(UadpDataSetMessageContentMask.Status | UadpDataSetMessageContentMask.SequenceNumber),
};
dataSetReaderAllTypes.MessageSettings = new ExtensionObject(uadpDataSetReaderMessage);
// Create and set DataSetMetaData for DataSet AllTypes
DataSetMetaDataType allTypesMetaData = CreateDataSetMetaDataAllTypes();
dataSetReaderAllTypes.DataSetMetaData = allTypesMetaData;
// Create and set SubscribedDataSet
subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in allTypesMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexAllTypes),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderAllTypes.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderAllTypes);
#endregion
pubSubConnection1.ReaderGroups.Add(readerGroup1);
//create pub sub configuration root object
PubSubConfigurationDataType pubSubConfiguration = new PubSubConfigurationDataType();
pubSubConfiguration.Connections = new PubSubConnectionDataTypeCollection()
{
pubSubConnection1
};
return(pubSubConfiguration);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dataSetDecodeErrorReason"></param>
/// <param name="networkMessage"></param>
/// <param name="dataSetReader"></param>
public DataSetDecodeErrorEventArgs(DataSetDecodeErrorReason dataSetDecodeErrorReason, UaNetworkMessage networkMessage, DataSetReaderDataType dataSetReader)
{
m_dataSetDecodeErrorReason = dataSetDecodeErrorReason;
m_networkMessage = networkMessage;
m_dataSetReader = dataSetReader;
}
/// <summary>
/// Creates a Subscriber PubSubConfiguration object for MQTT & Json programmatically.
/// </summary>
/// <returns></returns>
private static PubSubConfigurationDataType CreateSubscriberConfiguration_MqttJson(string urlAddress)
{
// Define a PubSub connection with PublisherId 2
PubSubConnectionDataType pubSubConnection1 = new PubSubConnectionDataType();
pubSubConnection1.Name = "Subscriber Connection3 MQTT Json";
pubSubConnection1.Enabled = true;
pubSubConnection1.PublisherId = (UInt16)2;
pubSubConnection1.TransportProfileUri = Profiles.PubSubMqttJsonTransport;
NetworkAddressUrlDataType address = new NetworkAddressUrlDataType();
// Specify the local Network interface name to be used
// e.g. address.NetworkInterface = "Ethernet";
// Leave empty to subscribe on all available local interfaces.
address.NetworkInterface = String.Empty;
address.Url = urlAddress;
pubSubConnection1.Address = new ExtensionObject(address);
// Configure the mqtt specific configuration with the MQTTbroker
ITransportProtocolConfiguration mqttConfiguration = new MqttClientProtocolConfiguration(version: EnumMqttProtocolVersion.V500);
pubSubConnection1.ConnectionProperties = mqttConfiguration.ConnectionProperties;
// Define "Simple" MetaData
DataSetMetaDataType simpleMetaData = CreateDataSetMetaDataSimple();
// Define "AllTypes" Metadata
DataSetMetaDataType allTypesMetaData = CreateDataSetMetaDataAllTypes();
#region Define ReaderGroup1
ReaderGroupDataType readerGroup1 = new ReaderGroupDataType();
readerGroup1.Name = "ReaderGroup 1";
readerGroup1.Enabled = true;
readerGroup1.MaxNetworkMessageSize = 1500;
readerGroup1.MessageSettings = new ExtensionObject(new ReaderGroupMessageDataType());
readerGroup1.TransportSettings = new ExtensionObject(new ReaderGroupTransportDataType());
#region Define DataSetReader1 'Simple' for PublisherId = (UInt16)3, DataSetWriterId = 1
DataSetReaderDataType dataSetReaderSimple = new DataSetReaderDataType();
dataSetReaderSimple.Name = "Reader 1 MQTT JSON Variant Encoding";
dataSetReaderSimple.PublisherId = (UInt16)2;
dataSetReaderSimple.WriterGroupId = 1;
dataSetReaderSimple.DataSetWriterId = 1;
dataSetReaderSimple.Enabled = true;
dataSetReaderSimple.DataSetFieldContentMask = 0;// Variant encoding;
dataSetReaderSimple.KeyFrameCount = 1;
dataSetReaderSimple.DataSetMetaData = simpleMetaData;
BrokerDataSetReaderTransportDataType brokerTransportSettings = new BrokerDataSetReaderTransportDataType()
{
QueueName = "Json_WriterGroup_1",
};
dataSetReaderSimple.TransportSettings = new ExtensionObject(brokerTransportSettings);
JsonDataSetReaderMessageDataType jsonDataSetReaderMessage = new JsonDataSetReaderMessageDataType()
{
NetworkMessageContentMask = (uint)(uint)(JsonNetworkMessageContentMask.NetworkMessageHeader
| JsonNetworkMessageContentMask.DataSetMessageHeader
| JsonNetworkMessageContentMask.PublisherId
| JsonNetworkMessageContentMask.DataSetClassId
| JsonNetworkMessageContentMask.ReplyTo),
DataSetMessageContentMask = (uint)(JsonDataSetMessageContentMask.DataSetWriterId
| JsonDataSetMessageContentMask.MetaDataVersion
| JsonDataSetMessageContentMask.SequenceNumber
| JsonDataSetMessageContentMask.Status
| JsonDataSetMessageContentMask.Timestamp),
};
dataSetReaderSimple.MessageSettings = new ExtensionObject(jsonDataSetReaderMessage);
TargetVariablesDataType subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in simpleMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexSimple),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderSimple.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderSimple);
#region Define DataSetReader2 'AllTypes' for PublisherId = (UInt16)2, DataSetWriterId = 1
DataSetReaderDataType dataSetReaderAllTypes = new DataSetReaderDataType();
dataSetReaderAllTypes.Name = "Reader 2 MQTT JSON RawData Encoding";
dataSetReaderAllTypes.PublisherId = (UInt16)2;
dataSetReaderAllTypes.WriterGroupId = 1;
dataSetReaderAllTypes.DataSetWriterId = 2;
dataSetReaderAllTypes.Enabled = true;
dataSetReaderAllTypes.DataSetFieldContentMask = (uint)DataSetFieldContentMask.RawData;
dataSetReaderAllTypes.KeyFrameCount = 1;
dataSetReaderAllTypes.DataSetMetaData = allTypesMetaData;
brokerTransportSettings = new BrokerDataSetReaderTransportDataType()
{
QueueName = "Json_WriterGroup_1",
};
dataSetReaderAllTypes.TransportSettings = new ExtensionObject(brokerTransportSettings);
jsonDataSetReaderMessage = new JsonDataSetReaderMessageDataType()
{
NetworkMessageContentMask = (uint)(JsonNetworkMessageContentMask.NetworkMessageHeader
| JsonNetworkMessageContentMask.DataSetMessageHeader
| JsonNetworkMessageContentMask.PublisherId
| JsonNetworkMessageContentMask.DataSetClassId
| JsonNetworkMessageContentMask.ReplyTo),
DataSetMessageContentMask = (uint)(JsonDataSetMessageContentMask.DataSetWriterId
| JsonDataSetMessageContentMask.MetaDataVersion
| JsonDataSetMessageContentMask.SequenceNumber
| JsonDataSetMessageContentMask.Status
| JsonDataSetMessageContentMask.Timestamp),
};
dataSetReaderAllTypes.MessageSettings = new ExtensionObject(jsonDataSetReaderMessage);
subscribedDataSet = new TargetVariablesDataType();
subscribedDataSet.TargetVariables = new FieldTargetDataTypeCollection();
foreach (var fieldMetaData in allTypesMetaData.Fields)
{
subscribedDataSet.TargetVariables.Add(new FieldTargetDataType()
{
DataSetFieldId = fieldMetaData.DataSetFieldId,
TargetNodeId = new NodeId(fieldMetaData.Name, NamespaceIndexSimple),
AttributeId = Attributes.Value,
OverrideValueHandling = OverrideValueHandling.OverrideValue,
OverrideValue = new Variant(TypeInfo.GetDefaultValue(fieldMetaData.DataType, (int)ValueRanks.Scalar))
});
}
dataSetReaderAllTypes.SubscribedDataSet = new ExtensionObject(subscribedDataSet);
#endregion
readerGroup1.DataSetReaders.Add(dataSetReaderAllTypes);
#endregion
pubSubConnection1.ReaderGroups.Add(readerGroup1);
//create pub sub configuration root object
PubSubConfigurationDataType pubSubConfiguration = new PubSubConfigurationDataType();
pubSubConfiguration.Connections = new PubSubConnectionDataTypeCollection()
{
pubSubConnection1
};
return(pubSubConfiguration);
}
