public static DeltaFrame Decode(Stream inputStream, DataFrame dataFrame, MetaFrame meta)
{
if (inputStream == null || !inputStream.CanRead || meta == null)
{
return(null);
}
DeltaFrame instance = new DeltaFrame(dataFrame);
instance.MetaFrame = meta;
instance.Timestamp = dataFrame.Timestamp;
ushort?readuInt16 = BaseType.ReadUInt16(inputStream);
if (readuInt16 != null)
{
instance.FieldCount = readuInt16.Value;
}
instance.Items = new List <DataPointValue>(instance.FieldCount);
instance.FieldIndexList = new List <ushort>(instance.FieldCount);
for (int i = 0; i < instance.FieldCount; i++)
{
// Index
ushort?indexFromStream = BaseType.ReadUInt16(inputStream);
if (!indexFromStream.HasValue)
{
throw new Exception("Decode DeltaFrame: Could not parse field index.");
}
instance.FieldIndexList.Add(indexFromStream.Value);
DataPointValue item = ParseDataPoint(inputStream, meta, indexFromStream.Value);
if (item != null)
{
instance.Items.Add(item);
}
}
return(instance);
}
public static KeyFrame Decode(Stream inputStream, DataFrame dataFrame, MetaFrame meta)
{
if (inputStream == null || !inputStream.CanRead || meta == null)
{
return(null);
}
KeyFrame instance = new KeyFrame(dataFrame);
instance.MetaFrame = meta;
instance.Timestamp = dataFrame.Timestamp;
ushort fieldCount = (ushort)(meta.FieldMetaDataList?.Count ?? 0);
ushort?readUInt16 = BaseType.ReadUInt16(inputStream);
if (readUInt16 == null)
{
return(null);
}
if (readUInt16.Value != fieldCount)
{
Logger.Error($"Number of fields from Meta: {meta.FieldMetaDataList.Count} vs. FieldCount: {readUInt16.Value}");
return(null);
}
instance.Items = new List <DataPointValue>(fieldCount);
for (ushort index = 0; index < fieldCount; index++)
{
DataPointValue item = ParseDataPoint(inputStream, meta, index);
if (item != null)
{
instance.Items.Add(item);
}
}
return(instance);
}
protected void AddDataPointMeta(DataPointValue dataPoint)
{
if (m_MetaFrame.FieldMetaDataList == null)
{
m_MetaFrame.FieldMetaDataList = new List <FieldMetaData>();
}
if (m_MetaFrame.StructureDataTypes == null)
{
m_MetaFrame.StructureDataTypes = new Dictionary <NodeID, StructureDescription>();
}
if (m_MetaFrame.EnumDataTypes == null)
{
m_MetaFrame.EnumDataTypes = new Dictionary <NodeID, EnumDescription>();
}
if (m_MetaFrame.Namespaces == null)
{
m_MetaFrame.Namespaces = new List <String>(3);
m_MetaFrame.Namespaces.Add(new String());
m_MetaFrame.Namespaces.Add(new String("http://siemens.com/energy/schema/opcua/ps/v2"));
m_MetaFrame.Namespaces.Add(new String("https://mindsphere.io/OPCUAPubSub/v3"));
}
int index = m_MetaFrame.FieldMetaDataList.FindIndex(x => x.DataType == dataPoint.NodeID);
FieldMetaData field = m_MetaFrame.FieldMetaDataList[index];
//string datatype = ProcessValueFactory.ConvertNodeIDSToString( dataPoint.NodeID );
//if ( datatype == "EnumValue" )
//{
// StructureDescription desc = IntegerValue.IntegerValueStructureDescription;
// desc.DataTypeId = dataPoint.NodeID;
// desc.Name.Name.Value = "EnumValue_" + dataPoint.EnumDescription.Name.Name.Value;
// m_MetaFrame.StructureDataTypes[field.DataType] = desc;
// //DataPointsManager.StructureDescriptions[field.DataType] = desc;
// EnumDescription enumDescription = dataPoint.EnumDescription;
// /*
// * This is the fix for defect
// * #15 - StructureDataType has same NodeId value with EnumDataType
// * Need to validate this fix to figure out any other better fix available.
// */
// NodeID Id = new NodeID
// {
// Namespace = 1,
// Value = (ushort) ( 100 + m_MetaFrame.EnumDataTypes.Count )
// };
// enumDescription.DataTypeID = Id;
// if ( !m_MetaFrame.EnumDataTypes.ContainsKey( enumDescription.DataTypeID ) )
// {
// m_MetaFrame.EnumDataTypes.Add( enumDescription.DataTypeID, enumDescription );
// }
//}
//else
//{
m_MetaFrame.StructureDataTypes[field.DataType] = dataPoint.StructureDescription;
//}
}
protected static DataPointValue ParseDataPoint(Stream inputStream, MetaFrame meta, ushort index)
{
if (index > meta.FieldMetaDataList.Count - 1)
{
throw new Exception("Decode DeltaFrame: Could not parse field as corresponding meta data is not present");
}
// Value
FieldMetaData metaData = meta.FieldMetaDataList[index];
if (metaData.Index != index)
{
Logger.Error($"Index does not match: FieldMetaData.Index {metaData.Index} != {index} read from Stream.");
}
if (Logger.IsDebugEnabled)
{
Logger.Debug($"Decoding item at position {index} in Meta Frame. Using FieldMetaData:");
Logger.Debug(metaData);
}
DataPointValue item = null;
if (metaData.DataType == File.PreDefinedNodeID)
{
item = new File();
item.Decode(inputStream);
}
else
{
item = ProcessValueFactory.CreateValue(metaData.DataType);
item.Properties = metaData.Properties;
if (meta.StructureDataTypes.TryGetValue(metaData.DataType, out StructureDescription desc))
{
if (meta.EnumDataTypes != null &&
desc.Name.Name.ToString()
.Contains("EnumValue", StringComparison.InvariantCultureIgnoreCase))
{
string enumName = desc.Name.Name.Value
.Substring(10);
item.EnumDescription = meta.EnumDataTypes.First(s => s.Value.Name.Name.Value == enumName)
.Value;
}
item.Decode(inputStream);
}
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (item == null)
{
Logger.Error($"Unable to decode value {metaData.DataType} at position {index} in message.");
return(null);
}
item.Name = metaData.Name.Value;
item.Properties = metaData.Properties;
item.Index = index;
return(item);
}
public byte[] GetEncodedDeltaFrame(ushort sequenceNumber)
{
DeltaFrame delta = new DeltaFrame();
delta.ConfigurationVersion = m_MetaFrame.ConfigurationVersion;
delta.MetaFrame = m_MetaFrame;
delta.NetworkMessageHeader = new NetworkMessageHeader
{
PublisherID = new String(PublisherId),
VersionAndFlags = 0xD1,
ExtendedFlags1 = new ExtendedFlags1
{
RawValue = 0x04
}
};
delta.Flags1 = new DataSetFlags1
{
RawValue = 0xEB
};
delta.Flags2 = new DataSetFlags2
{
RawValue = 0x11
};
delta.FieldIndexList = new List <ushort>();
delta.PayloadHeader = new DataSetPayloadHeader
{
Count = 1,
DataSetWriterID = new[] { m_MetaFrame.DataSetWriterID }
};
delta.Items = new List <DataPointValue>();
delta.FieldIndexList = new List <ushort>();
for (int i = 0; i < m_ProcessValues.Values.Count; i++)
{
if (m_ProcessValues.Values.ElementAt(i)
.IsModified)
{
DataPointValue dataPoint = m_ProcessValues.Values.ElementAt(i)
.DataPoint;
dataPoint.Index = i;
delta.Items.Add(dataPoint);
m_ProcessValues.Values.ElementAt(i)
.IsModified = false;
delta.FieldIndexList.Add((ushort)i);
}
}
delta.FieldCount = (ushort)delta.Items.Count;
delta.DataSetMessageSequenceNumber = sequenceNumber;
delta.Timestamp = DateTime.Now;
using (MemoryStream outputStream = new MemoryStream())
{
delta.Encode(outputStream);
return(outputStream.ToArray());
}
}
public void UpdateDataPoint(ProcessDataPointValue dataPoint)
{
DataPointValue baseValue = GetDataPointValue(dataPoint.Name);
if (baseValue == null)
{
AddDataPoint(dataPoint);
}
else
{
(baseValue as ProcessDataPointValue)?.Update(dataPoint);
SetDataPointModified(baseValue.Name);
}
}
protected static void WriteSingleDataPoint(Stream outputStream, DataPointValue dpv)
{
switch (dpv)
{
case ProcessDataPointValue pdv:
{
pdv.Encode(outputStream);
break;
}
case File file:
file.Encode(outputStream);
break;
case null:
throw new NullReferenceException("Empty DataPointValue.");
default:
throw new Exception("Unsupported DataType for encoding.");
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("");
sb.AppendLine("=============================================================================================================================================="
);
sb.AppendLine("Delta Message");
sb.AppendLine("----------------------------------------------------------------------------------------------------------------------------------------------"
);
sb.AppendLine($"{"Index",10} | {"Name",50} | {"Orcat",10} | {"Quality",10} | {"Custom",10} | {"MDSP q",10} | {"Timestamp",21} | {"Value",20}");
sb.AppendLine("----------------------------------------------------------------------------------------------------------------------------------------------"
);
for (int i = 0; i < Items.Count; i++)
{
DataPointValue dpv = Items[i];
string name = "";
string value = "";
switch (dpv)
{
case ProcessDataPointValue pdv:
value = pdv.ToString();
break;
case File file:
value = file.ToString();
break;
}
if (MetaFrame?.FieldMetaDataList != null && i < MetaFrame.FieldMetaDataList.Count)
{
name = MetaFrame.FieldMetaDataList[dpv.Index]
.Name.ToString();
}
sb.AppendLine($"{FieldIndexList[i],10} | {name,-50} | {value}");
}
sb.AppendLine("=============================================================================================================================================="
);
sb.AppendLine();
return(sb.ToString());
}
protected KeyFrame GetKeyFrame(ushort sequenceNumber)
{
KeyFrame key = new KeyFrame();
key.ConfigurationVersion = m_MetaFrame.ConfigurationVersion;
key.NetworkMessageHeader = new NetworkMessageHeader
{
PublisherID = new String(PublisherId),
VersionAndFlags = 0xD1,
ExtendedFlags1 = new ExtendedFlags1
{
RawValue = 0x04
}
};
key.Flags1.RawValue = 0xEB;
key.Flags2.RawValue = 0x10;
key.MetaFrame = m_MetaFrame;
key.Items = new List <DataPointValue>();
for (int i = 0; i < m_ProcessValues.Values.Count; i++)
{
DataPointValue dataPoint = m_ProcessValues.Values.ElementAt(i)
.DataPoint;
dataPoint.Index = i;
key.Items.Add(dataPoint);
m_ProcessValues.Values.ElementAt(i)
.IsModified = false;
}
key.PayloadHeader = new DataSetPayloadHeader
{
Count = 1,
DataSetWriterID = new[] { m_MetaFrame.DataSetWriterID }
};
key.DataSetMessageSequenceNumber = sequenceNumber;
key.Timestamp = DateTime.Now;
return(key);
}
private string GetValueFromDataPointValue(DataPointValue dpv)
{
string text = string.Empty;
if (dpv is File file)
{
return($"NAME [{file.Path}] [{file.Content.Length}]");
}
if (dpv is ProcessDataPointValue pdpv)
{
if (dpv.EnumDescription != null)
{
StructureDescription desc = null; //DataPointsManager.GetEnumStructureDescription(dpv.EnumDescription.Name.Name.Value);
if (desc != null)
{
string enumName = desc.Name.Name.Value.Substring(10);
foreach (EnumField enumField in dpv.EnumDescription.Fields)
{
if (enumField.Value == (int)pdpv.Value)
{
text = string.Concat(enumField.Name.Value, " [ ", enumField.Value, " ]");
break;
}
}
}
}
else
{
text = string.Concat(text, "[ ", pdpv.Value, " ]");
if (pdpv is CounterValue)
{
text = string.Concat(text,
"-[ ",
pdpv.GetAttributeValue(CounterValue.QuantityAttributeName)
.ToString(),
" ]"
);
}
if (dpv is StepPosValue || dpv is StepPosEvent)
{
text = string.Concat(text,
"-[ ",
pdpv.GetAttributeValue(StepPosValue.TransientAttributeName)
.ToString(),
" ]"
);
}
if (pdpv is ComplexMeasuredValue)
{
text = string.Concat(text,
"-[ ",
pdpv.GetAttributeValue(ComplexMeasuredValue.AngleAttributeName)
.ToString(),
" ]"
);
}
}
}
if (string.IsNullOrEmpty(text))
{
text = "Could not parse value";
}
return(text);
}
