public void TestKeyFrame(ProcessDataPointValue dataPoint)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
dataSet.AddDataPoint(dataPoint);
DecodeMessage decoder = new DecodeMessage();
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
byte[] encodedKey = dataSet.GetEncodedKeyFrame(2);
NetworkMessage metaNetworkMessage = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(metaNetworkMessage, Is.Not.Null);
Assert.That(metaNetworkMessage, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(metaNetworkMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
NetworkMessage keyNetworkMessage = decoder.ParseBinaryMessage(encodedKey);
Assert.That(keyNetworkMessage, Is.Not.Null);
Assert.That(keyNetworkMessage, Is.InstanceOf(typeof(KeyFrame)));
Assert.That(keyNetworkMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
KeyFrame decodedKeyMessage = (KeyFrame)keyNetworkMessage;
ProcessDataPointValue decodedDataPoint = (ProcessDataPointValue)decodedKeyMessage.Items[0];
Common.AssertDataPointsAreEqual(dataPoint, decodedDataPoint);
Assert.That(decodedKeyMessage, Is.Not.Null);
Assert.That(decodedKeyMessage.Items, Is.Not.Empty);
Assert.That(decodedKeyMessage.Items.Count, Is.EqualTo(1));
Assert.That(decodedKeyMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
}
public static void AssertDataPointsAreEqual(ProcessDataPointValue encoded, ProcessDataPointValue decoded)
{
Assert.That(encoded.Name, Is.EqualTo(decoded.Name));
Assert.That(encoded.Orcat, Is.EqualTo(decoded.Orcat));
Assert.That(encoded.Quality, Is.EqualTo(decoded.Quality));
Assert.That(encoded.Value, Is.EqualTo(decoded.Value));
Assert.That(encoded.Timestamp, Is.EqualTo(decoded.Timestamp));
}
public void AddDataPoint(ProcessDataPointValue dataPoint)
{
if (!m_ProcessValues.ContainsKey(dataPoint.Name))
{
DataPointEntry entry = new DataPointEntry
{
DataPoint = dataPoint,
IsModified = true
};
m_ProcessValues.Add(dataPoint.Name, entry);
m_MetaFrame = null;
}
}
public void UpdateDataPoint(ProcessDataPointValue dataPoint)
{
DataPointValue baseValue = GetDataPointValue(dataPoint.Name);
if (baseValue == null)
{
AddDataPoint(dataPoint);
}
else
{
(baseValue as ProcessDataPointValue)?.Update(dataPoint);
SetDataPointModified(baseValue.Name);
}
}
internal static DataPointValue GetDataPointValue(DeltaEntry keyEntry, DataSetType dataSetType)
{
ProcessDataPointValue dpv = ProcessValueFactory.CreateValue(keyEntry.DataType);
if (dpv == null)
{
Logger.Error($"Unable to create DataPoint for entry: {keyEntry}");
return(null);
}
dpv.Orcat = keyEntry.Orcat;
dpv.Quality = keyEntry.Quality;
dpv.Timestamp = keyEntry.TimeStamp;
dpv.Value = keyEntry.Value;
if (keyEntry is KeyEntry key)
{
dpv.Prefix = key.Prefix;
dpv.Unit = key.Unit;
dpv.FieldID = key.FieldID;
}
if (dpv is CounterValue)
{
dpv.SetAttributeValue(CounterValue.QuantityAttributeName, keyEntry.Value2);
}
if (dpv is StepPosValue || dpv is StepPosEvent)
{
dpv.SetAttributeValue(StepPosValue.TransientAttributeName, keyEntry.Value2);
}
if (dpv is ComplexMeasuredValue)
{
dpv.SetAttributeValue(ComplexMeasuredValue.AngleAttributeName, keyEntry.Value2);
}
if (dpv.Timestamp == 0)
{
dpv.Timestamp = DateTime.Now.ToFileTimeUtc();
}
return(dpv);
}
public void TestMetaFrame(ProcessDataPointValue dataPoint)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
dataSet.AddDataPoint(dataPoint);
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
DecodeMessage decoder = new DecodeMessage();
NetworkMessage decodedMeta = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(decodedMeta, Is.Not.Null);
Assert.That(decodedMeta, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(decodedMeta.NetworkMessageHeader.ExtendedFlags2.MessageType, Is.EqualTo(Header.MessageType.DiscoveryResponse));
Assert.That(decodedMeta.NetworkMessageHeader.ExtendedFlags2.Chunk, Is.False);
Assert.That(decodedMeta.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
decoder = new DecodeMessage();
List <byte[]> encodedMetaChunkedZero = dataSet.GetChunkedMetaFrame(0, new EncodingOptions(), 1);
NetworkMessage decodedMetaChunkedZero = decoder.ParseBinaryMessage(encodedMetaChunkedZero[0]);
Assert.That(decodedMetaChunkedZero, Is.Not.Null);
Assert.That(decodedMetaChunkedZero, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(decodedMetaChunkedZero.NetworkMessageHeader.ExtendedFlags2.MessageType, Is.EqualTo(Header.MessageType.DiscoveryResponse));
Assert.That(decodedMetaChunkedZero.NetworkMessageHeader.ExtendedFlags2.Chunk, Is.False);
Assert.That(decodedMetaChunkedZero.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
decoder = new DecodeMessage();
List <byte[]> encodedMetaChunked = dataSet.GetChunkedMetaFrame(1024 * 14, new EncodingOptions(), 1);
NetworkMessage decodedMetaChunked = decoder.ParseBinaryMessage(encodedMetaChunked[0]);
Assert.That(decodedMetaChunked, Is.Not.Null);
Assert.That(decodedMetaChunked, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(decodedMetaChunked.NetworkMessageHeader.ExtendedFlags2.MessageType, Is.EqualTo(Header.MessageType.DiscoveryResponse));
Assert.That(decodedMetaChunked.NetworkMessageHeader.ExtendedFlags2.Chunk, Is.True);
Assert.That(decodedMetaChunked.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
}
