/// <summary>
/// Returns a FLOAT32, INT32 or DOUBLE64 value from the device.
/// </summary>
/// <param name="address">Device Address. Use null to use the DefaultDeviceAddress defined on MeComQuerySet.</param>
/// <param name="parameterId">Device Parameter ID.</param>
/// <param name="instance">Parameter Instance. (usually 1)</param>
/// <param name="type">Specifies the type of the value to be read.</param>
/// <returns>Returned value.</returns>
/// <exception cref="ComCommandException">when the command fails. Check the inner exception for details.</exception>
public dynamic GetValue(byte?address, UInt16 parameterId, byte instance, MeParType type)
{
try
{
MeComPacket txFrame = new MeComPacket('#', address);
MeComVarConvert.AddString(txFrame.Payload, "?VR");
MeComVarConvert.AddUint16(txFrame.Payload, parameterId);
MeComVarConvert.AddUint8(txFrame.Payload, instance);
MeComPacket rxFrame = meQuerySet.Query(txFrame);
switch (type)
{
case MeParType.FLOAT32:
return(MeComVarConvert.ReadFloat32(rxFrame.Payload));
case MeParType.INT32:
return(MeComVarConvert.ReadInt32(rxFrame.Payload));
case MeParType.DOUBLE64:
return(MeComVarConvert.ReadDouble64(rxFrame.Payload));
default:
throw new ArgumentOutOfRangeException("Unknown Type. Received value: " + type);
}
}
catch (Exception Ex)
{
throw new ComCommandException(String.Format("Get Value failed: Address: {0}; ID: {1}; Inst: {2}; Detail: {3}", address, parameterId, instance, Ex.Message), Ex);
}
}
/// <summary>
/// Returns Meta data of the parameter.
/// </summary>
/// <param name="address">Device Address. Use null to use the DefaultDeviceAddress defined on MeComQuerySet.</param>
/// <param name="parameterId">Device Parameter ID.</param>
/// <param name="instance">Parameter Instance. (usually 1)</param>
/// <returns>Returned meta data object.</returns>
/// <exception cref="ComCommandException">when the command fails. Check the inner exception for details.</exception>
public ParMetaData GetMetaData(byte?address, UInt16 parameterId, byte instance)
{
ParMetaData parMetaData = new ParMetaData();
try
{
MeComPacket txFrame = new MeComPacket('#', address);
MeComVarConvert.AddString(txFrame.Payload, "?VM");
MeComVarConvert.AddUint16(txFrame.Payload, parameterId);
MeComVarConvert.AddUint8(txFrame.Payload, instance);
MeComPacket rxFrame = meQuerySet.Query(txFrame);
parMetaData.Type = (MeParType)MeComVarConvert.ReadUint8(rxFrame.Payload);
parMetaData.Flags = (MeParFlags)MeComVarConvert.ReadUint8(rxFrame.Payload);
parMetaData.NrOfInst = MeComVarConvert.ReadUint8(rxFrame.Payload);
parMetaData.MaxNrOfElements = MeComVarConvert.ReadUint32(rxFrame.Payload);
switch (parMetaData.Type)
{
case MeParType.FLOAT32:
parMetaData.Min = MeComVarConvert.ReadFloat32(rxFrame.Payload);
parMetaData.Max = MeComVarConvert.ReadFloat32(rxFrame.Payload);
parMetaData.Value = MeComVarConvert.ReadFloat32(rxFrame.Payload);
break;
case MeParType.INT32:
parMetaData.Min = MeComVarConvert.ReadInt32(rxFrame.Payload);
parMetaData.Max = MeComVarConvert.ReadInt32(rxFrame.Payload);
parMetaData.Value = MeComVarConvert.ReadInt32(rxFrame.Payload);
break;
case MeParType.DOUBLE64:
parMetaData.Min = MeComVarConvert.ReadDouble64(rxFrame.Payload);
parMetaData.Max = MeComVarConvert.ReadDouble64(rxFrame.Payload);
parMetaData.Value = MeComVarConvert.ReadDouble64(rxFrame.Payload);
break;
case MeParType.LATIN1:
case MeParType.BYTE:
parMetaData.Min = MeComVarConvert.ReadUint8(rxFrame.Payload);
parMetaData.Max = MeComVarConvert.ReadUint8(rxFrame.Payload);
parMetaData.Value = null;
break;
default:
throw new ArgumentOutOfRangeException("Unknown Type received. Received value: " + parMetaData.Type);
}
return(parMetaData);
}
catch (Exception Ex)
{
throw new ComCommandException(String.Format("Get Meta Data failed: Address: {0}; ID: {1}; Inst: {2}; Detail: {3}", address, parameterId, instance, Ex.Message), Ex);
}
}
/// <summary>
/// Returns a double 64Bit value from the device.
/// </summary>
/// <param name="address">Device Address. Use null to use the DefaultDeviceAddress defined on MeComQuerySet.</param>
/// <param name="parameterId">Device Parameter ID.</param>
/// <param name="instance">Parameter Instance. (usually 1)</param>
/// <returns>Returned value.</returns>
/// <exception cref="ComCommandException">when the command fails. Check the inner exception for details.</exception>
public double GetDoubleValue(byte?address, UInt16 parameterId, byte instance)
{
try
{
MeComPacket txFrame = new MeComPacket('#', address);
MeComVarConvert.AddString(txFrame.Payload, "?VR");
MeComVarConvert.AddUint16(txFrame.Payload, parameterId);
MeComVarConvert.AddUint8(txFrame.Payload, instance);
MeComPacket rxFrame = meQuerySet.Query(txFrame);
return(MeComVarConvert.ReadDouble64(rxFrame.Payload));
}
catch (Exception Ex)
{
throw new ComCommandException(String.Format("Get Double Value failed: Address: {0}; ID: {1}; Inst: {2}; Detail: {3}", address, parameterId, instance, Ex.Message), Ex);
}
}
/// <summary>
/// Reads a list of values from the device within one command.
/// This is much more efficient than reading each value with an separate command.
/// </summary>
/// <param name="address">Device Address. Use null to use the DefaultDeviceAddress defined on MeComQuerySet.</param>
/// <param name="elements">List of parameter definitions to read from the device.</param>
/// <exception cref="ComCommandException">when the command fails. Check the inner exception for details.</exception>
public void BulkParRead(byte?address, List <BulkParElement> elements)
{
try
{
MeComPacket txFrame = new MeComPacket('#', address);
MeComVarConvert.AddString(txFrame.Payload, "?VX");
MeComVarConvert.AddUint8(txFrame.Payload, (byte)elements.Count);
foreach (BulkParElement item in elements)
{
MeComVarConvert.AddUint16(txFrame.Payload, item.ParameterId);
MeComVarConvert.AddUint8(txFrame.Payload, item.Instance);
}
MeComPacket rxFrame = meQuerySet.Query(txFrame);
foreach (BulkParElement item in elements)
{
switch (item.Type)
{
case MeParType.FLOAT32:
item.Value = MeComVarConvert.ReadFloat32(rxFrame.Payload);
break;
case MeParType.INT32:
item.Value = MeComVarConvert.ReadInt32(rxFrame.Payload);
break;
case MeParType.DOUBLE64:
item.Value = MeComVarConvert.ReadDouble64(rxFrame.Payload);
break;
}
}
}
catch (Exception Ex)
{
throw new ComCommandException(String.Format("Bulk Parameter read failed Detail: {0}", Ex.Message), Ex);
}
}
/// <summary>
/// Reads an array of FLOAT32, INT32, DOUBLE64 or ASCII (char) values form the device.
/// The data length is given by the device.
/// This method does only return when the device tells the host, that all data is read.
/// The data is read in an loop with several sub queries.
/// During this command is working, it is possible to use other commands with an different thread.
/// </summary>
/// <param name="address">Device Address. Use null to use the DefaultDeviceAddress defined on MeComQuerySet.</param>
/// <param name="parameterId">Device Parameter ID.</param>
/// <param name="instance">Parameter Instance. (usually 1)</param>
/// <param name="type">Specifies the type of the value to be read.</param>
/// <param name="callback">Is called every time when the progress has changed.</param>
/// <param name="expectedNrOfElements">Defines the expected number of elements to calculate the progress for the callback function.</param>
/// <returns>Returned value.</returns>
/// <exception cref="ComCommandException">when the command fails. Check the inner exception for details.</exception>
public dynamic GetBigData(byte?address, UInt16 parameterId, byte instance, MeParType type, ProgressUpdateCallback callback = null, int expectedNrOfElements = 0)
{
dynamic value;
try
{
ushort rcvElements;
bool hasMoreData;
uint totalReadElements = 0;
MemoryStream totalStream = new MemoryStream();
do
{
MeComPacket txFrame = new MeComPacket('#', address);
MeComVarConvert.AddString(txFrame.Payload, "?VB");
MeComVarConvert.AddUint16(txFrame.Payload, parameterId);
MeComVarConvert.AddUint8(txFrame.Payload, instance);
MeComVarConvert.AddUint32(txFrame.Payload, totalReadElements); //Read start position
MeComVarConvert.AddUint16(txFrame.Payload, UInt16.MaxValue); //Maximum Elements to read per call.
MeComPacket rxFrame = meQuerySet.Query(txFrame);
rcvElements = MeComVarConvert.ReadUint16(rxFrame.Payload);
hasMoreData = MeComVarConvert.ReadUint8(rxFrame.Payload) == 1;
totalReadElements += rcvElements;
if (rcvElements > 0)
{
rxFrame.Payload.CopyTo(totalStream);
}
callback?.Invoke(100.0 / expectedNrOfElements * totalReadElements);
} while (hasMoreData);
totalStream.Position = 0;
callback?.Invoke(100);
switch (type)
{
case MeParType.FLOAT32:
value = new float[totalReadElements];
break;
case MeParType.INT32:
value = new int[totalReadElements];
break;
case MeParType.DOUBLE64:
value = new double[totalReadElements];
break;
case MeParType.LATIN1:
value = "";
break;
case MeParType.BYTE:
value = new byte[totalReadElements];
break;
default:
throw new ArgumentOutOfRangeException("Unknown EParType: " + type);
}
for (int i = 0; i < totalReadElements; i++)
{
switch (type)
{
case MeParType.FLOAT32:
value[i] = MeComVarConvert.ReadFloat32(totalStream);
break;
case MeParType.INT32:
value[i] = MeComVarConvert.ReadInt32(totalStream);
break;
case MeParType.DOUBLE64:
value[i] = MeComVarConvert.ReadDouble64(totalStream);
break;
case MeParType.LATIN1:
value = MeComVarConvert.ReadEncodedString(totalStream, (int)totalReadElements);
return(value);
case MeParType.BYTE:
value[i] = MeComVarConvert.ReadUint8(totalStream);
break;
default:
throw new ArgumentOutOfRangeException("Unknown EParType: " + type);
}
}
return(value);
}
catch (Exception Ex)
{
throw new ComCommandException(String.Format("Get Value failed: Address: {0}; ID: {1}; Inst: {2}; Detail: {3}", address, parameterId, instance, Ex.Message), Ex);
}
}
