/// <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 the basic Meta data to 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> /// <param name="min">Minimal value. Is always a double value.</param> /// <param name="max">Maximal value. Is always a double value.</param> /// <exception cref="ComCommandException">when the command fails. Check the inner exception for details.</exception> public void GetLimits(byte?address, ushort parameterId, byte instance, out double min, out double max) { try { MeComPacket txFrame = new MeComPacket('#', address); MeComVarConvert.AddString(txFrame.Payload, "?VL"); MeComVarConvert.AddUint16(txFrame.Payload, parameterId); MeComVarConvert.AddUint8(txFrame.Payload, instance); MeComPacket rxFrame = meQuerySet.Query(txFrame); if (MeComVarConvert.ReadUint8(rxFrame.Payload) == 0) { //This is a float Value min = MeComVarConvert.ReadFloat32(rxFrame.Payload); max = MeComVarConvert.ReadFloat32(rxFrame.Payload); } else { //This is a INT32 Value min = MeComVarConvert.ReadInt32(rxFrame.Payload); max = MeComVarConvert.ReadInt32(rxFrame.Payload); } } catch (Exception Ex) { throw new ComCommandException(String.Format("Get Limit Values 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> /// Queries the Branch ID. /// The Branch ID can be used to identify several software branches from the same software. /// </summary> /// <param name="address">Device Address. Use null to use the DefaultDeviceAddress defined on MeComQuerySet.</param> /// <returns>Branch ID</returns> public int GetBranchId(byte?address) { try { MeComPacket txFrame = new MeComPacket('#', address); MeComVarConvert.AddString(txFrame.Payload, "?BI"); MeComPacket rxFrame = meQuerySet.Query(txFrame); return(MeComVarConvert.ReadInt32(rxFrame.Payload)); } catch (Exception Ex) { throw new ComCommandException(String.Format("Get Branch ID failed: Address: {0}; Detail: {1}", address, Ex.Message), Ex); } }
/// <summary> /// Returns a signed int 32Bit 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 int GetINT32Value(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.ReadInt32(rxFrame.Payload)); } catch (Exception Ex) { throw new ComCommandException(String.Format("Get INT32 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); } }