C# (CSharp) ByteTransformHelper Examples

Example #1

 /// <summary>
 /// 读取设备的uint类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 public OperateResult <uint> ReadUInt32(string address)
 {
     return(ByteTransformHelper.GetUInt32ResultFromBytes(Read(address, (ushort)(2 * WordLength)), byteTransform));
 }

Example #2

File: AllenBradleyNet.cs Project: xlichen/HslCommunication

 /// <summary>
 /// 读取PLC的double类型的数组 -> An array that reads the double type of the PLC
 /// </summary>
 /// <param name="address">节点的名称 -> Name of the node </param>
 /// <param name="length">数组长度 -> Array length </param>
 /// <returns>带有结果对象的结果数据 -> Result data with result info </returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadDoubleArray" title="Double类型示例" />
 /// </example>
 public override OperateResult <double[]> ReadDouble(string address, ushort length)
 {
     return(ByteTransformHelper.GetResultFromBytes(Read(address, length), m => ByteTransform.TransDouble(m, 0, length)));
 }

Example #3

 /// <summary>
 /// 读取设备的uint类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadUInt32" title="UInt32类型示例" />
 /// </example>
 public OperateResult <uint> ReadUInt32(string address)
 {
     return(ByteTransformHelper.GetResultFromArray(ReadUInt32(address, 1)));
 }

Example #4

File: ModbusRtu.cs Project: yangjx2018/HslCommunication

 /// <summary>
 /// 读取指定地址的ulong数据
 /// </summary>
 /// <param name="address">起始地址，格式为"1234"</param>
 /// <returns>带有成功标志的ulong数据</returns>
 public OperateResult <ulong> ReadUInt64(string address)
 {
     return(ByteTransformHelper.GetUInt64ResultFromBytes(Read(address, 4), byteTransform));
 }

Example #5

File: ModbusRtu.cs Project: yangjx2018/HslCommunication

 /// <summary>
 /// 读取地址地址的String数据，字符串编码为ASCII
 /// </summary>
 /// <param name="address">起始地址，格式为"1234"</param>
 /// <param name="length">字符串长度</param>
 /// <returns>带有成功标志的string数据</returns>
 public OperateResult <string> ReadString(string address, ushort length)
 {
     return(ByteTransformHelper.GetStringResultFromBytes(Read(address, length), byteTransform));
 }

Example #6

 /// <summary>
 /// 将指定的OperateResult类型转化
 /// </summary>
 /// <param name="result">原始的类型</param>
 /// <returns>转化后的类型</returns>
 protected OperateResult <string> GetStringResultFromBytes(OperateResult <byte[]> result)
 {
     return(ByteTransformHelper.GetStringResultFromBytes(result, byteTransform));
 }

Example #7

File: ModbusRtu.cs Project: yangjx2018/HslCommunication

 /// <summary>
 /// 读取指定地址的uint数据
 /// </summary>
 /// <param name="address">起始地址，格式为"1234"</param>
 /// <returns>带有成功标志的uint数据</returns>
 public OperateResult <uint> ReadUInt32(string address)
 {
     return(ByteTransformHelper.GetUInt32ResultFromBytes(Read(address, 2), byteTransform));
 }

Example #8

 public override OperateResult <uint[]> ReadUInt32(string address, ushort length) =>
 ByteTransformHelper.GetResultFromBytes <uint[]>(Read(address, length), m => ByteTransform.TransUInt32(m, 0, length));

Example #9

File: NetworkDataServerBase.cs Project: zd413/HslCommunication

 /// <summary>
 /// 读取设备的float类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadFloat" title="Float类型示例" />
 /// </example>
 public OperateResult <float> ReadFloat(string address)
 {
     return(ByteTransformHelper.GetResultFromArray(ReadFloat(address, 1)));
 }

Example #10

 public override OperateResult <float[]> ReadFloat(string address, ushort length) =>
 ByteTransformHelper.GetResultFromBytes <float[]>(Read(address, length), m => ByteTransform.TransSingle(m, 0, length));

Example #11

 public override OperateResult <long[]> ReadInt64(string address, ushort length) =>
 ByteTransformHelper.GetResultFromBytes <long[]>(Read(address, length), m => ByteTransform.TransInt64(m, 0, length));

Example #12

 /// <summary>
 /// 读取设备的double类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 public OperateResult <double> ReadDouble(string address)
 {
     return(ByteTransformHelper.GetDoubleResultFromBytes(Read(address, (ushort)(4 * WordLength)), byteTransform));
 }

Example #13

 /// <summary>
 /// 读取设备的ulong类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 public OperateResult <ulong> ReadUInt64(string address)
 {
     return(ByteTransformHelper.GetUInt64ResultFromBytes(Read(address, (ushort)(4 * WordLength)), byteTransform));
 }

Example #14

 /// <summary>
 /// 读取设备的float类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 public OperateResult <float> ReadFloat(string address)
 {
     return(ByteTransformHelper.GetSingleResultFromBytes(Read(address, (ushort)(2 * WordLength)), byteTransform));
 }

Example #15

 /// <summary>
 /// 将指定的OperateResult类型转化
 /// </summary>
 /// <param name="result">原始的类型</param>
 /// <returns>转化后的类型</returns>
 protected OperateResult <float> GetSingleResultFromBytes(OperateResult <byte[]> result)
 {
     return(ByteTransformHelper.GetSingleResultFromBytes(result, byteTransform));
 }

Example #16

File: NetworkDataServerBase.cs Project: zd413/HslCommunication

 /// <summary>
 /// 读取设备的long类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadInt64" title="Int64类型示例" />
 /// </example>
 public OperateResult <long> ReadInt64(string address)
 {
     return(ByteTransformHelper.GetResultFromArray(ReadInt64(address, 1)));
 }

Example #17

 /// <summary>
 /// 将指定的OperateResult类型转化
 /// </summary>
 /// <param name="result">原始的类型</param>
 /// <returns>转化后的类型</returns>
 protected OperateResult <double> GetDoubleResultFromBytes(OperateResult <byte[]> result)
 {
     return(ByteTransformHelper.GetDoubleResultFromBytes(result, byteTransform));
 }

Example #18

File: NetworkDataServerBase.cs Project: zd413/HslCommunication

 /// <summary>
 /// 读取设备的double类型的数组
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <param name="length">数组长度</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadDoubleArray" title="Double类型示例" />
 /// </example>
 public virtual OperateResult <double[]> ReadDouble(string address, ushort length)
 {
     return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength * 4)), m => ByteTransform.TransDouble(m, 0, length)));
 }

Example #19

File: ModbusRtu.cs Project: yangjx2018/HslCommunication

 /// <summary>
 /// 读取指定地址的ushort数据
 /// </summary>
 /// <param name="address">起始地址，格式为"1234"</param>
 /// <returns>带有成功标志的ushort数据</returns>
 public OperateResult <ushort> ReadUInt16(string address)
 {
     return(ByteTransformHelper.GetUInt16ResultFromBytes(Read(address, 1), byteTransform));
 }

Example #20

File: NetworkDataServerBase.cs Project: zd413/HslCommunication

 /// <summary>
 /// 读取设备的字符串数据，编码为ASCII
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <param name="length">地址长度</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadString" title="String类型示例" />
 /// </example>
 public OperateResult <string> ReadString(string address, ushort length)
 {
     return(ByteTransformHelper.GetResultFromBytes(Read(address, length), m => ByteTransform.TransString(m, 0, m.Length, Encoding.ASCII)));
 }

Example #21

File: ModbusRtu.cs Project: yangjx2018/HslCommunication

 /// <summary>
 /// 读取指定地址的float数据
 /// </summary>
 /// <param name="address">起始地址，格式为"1234"</param>
 /// <returns>带有成功标志的float数据</returns>
 public OperateResult <float> ReadFloat(string address)
 {
     return(ByteTransformHelper.GetSingleResultFromBytes(Read(address, 2), byteTransform));
 }

Example #22

 /// <summary>
 /// 读取指定地址的byte数据 -> Reads the byte data for the specified address
 /// </summary>
 /// <param name="address">起始地址，格式为M100,I100,Q100,DB1.100 -> Starting address, formatted as M100,I100,Q100,DB1.100</param>
 /// <returns>byte类型的结果对象 -> Result object of type Byte</returns>
 /// <remarks>
 /// <note type="warning">
 /// 不适用于DB块，定时器，计数器的数据读取，会提示相应的错误，读取长度必须为偶数
 /// </note>
 /// </remarks>
 public OperateResult <byte> ReadByte(string address)
 {
     return(ByteTransformHelper.GetResultFromArray(Read(address, 1)));
 }

Example #23

File: ModbusRtu.cs Project: yangjx2018/HslCommunication

 /// <summary>
 /// 读取指定地址的double数据
 /// </summary>
 /// <param name="address">起始地址，格式为"1234"</param>
 /// <returns>带有成功标志的double数据</returns>
 public OperateResult <double> ReadDouble(string address)
 {
     return(ByteTransformHelper.GetDoubleResultFromBytes(Read(address, 4), byteTransform));
 }

Example #24

 /// <summary>
 /// 将指定的OperateResult类型转化
 /// </summary>
 /// <param name="result">原始的类型</param>
 /// <returns>转化后的类型</returns>
 protected OperateResult <bool> GetBoolResultFromBytes(OperateResult <byte[]> result)
 {
     return(ByteTransformHelper.GetBoolResultFromBytes(result, byteTransform));
 }

Example #25

File: AllenBradleyNet.cs Project: xlichen/HslCommunication

 /// <summary>
 /// 读取PLC的ulong类型的数组 -> An array that reads the ULONG type of the PLC
 /// </summary>
 /// <param name="address">节点的名称 -> Name of the node </param>
 /// <param name="length">数组长度 -> Array length </param>
 /// <returns>带有结果对象的结果数据 -> Result data with result info </returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadUInt64Array" title="UInt64类型示例" />
 /// </example>
 public override OperateResult <ulong[]> ReadUInt64(string address, ushort length)
 {
     return(ByteTransformHelper.GetResultFromBytes(Read(address, length), m => ByteTransform.TransUInt64(m, 0, length)));
 }

Example #26

 /// <summary>
 /// 将指定的OperateResult类型转化
 /// </summary>
 /// <param name="result">原始的类型</param>
 /// <returns>转化后的类型</returns>
 protected OperateResult <int> GetInt32ResultFromBytes(OperateResult <byte[]> result)
 {
     return(ByteTransformHelper.GetInt32ResultFromBytes(result, byteTransform));
 }

Example #27

 /// <summary>
 /// 读取设备的short类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadInt16" title="Int16类型示例" />
 /// </example>
 public OperateResult <short> ReadInt16(string address)
 {
     return(ByteTransformHelper.GetResultFromArray(ReadInt16(address, 1)));
 }

Example #28

 /// <summary>
 /// 将指定的OperateResult类型转化
 /// </summary>
 /// <param name="result">原始的类型</param>
 /// <returns>转化后的类型</returns>
 protected OperateResult <ulong> GetUInt64ResultFromBytes(OperateResult <byte[]> result)
 {
     return(ByteTransformHelper.GetUInt64ResultFromBytes(result, byteTransform));
 }

Example #29

 /// <summary>
 /// 读取设备的uint类型的数组
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <param name="length">数组长度</param>
 /// <returns>带成功标志的结果数据对象</returns>
 /// <example>
 /// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
 /// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="ReadUInt32Array" title="UInt32类型示例" />
 /// </example>
 public virtual OperateResult <uint[]> ReadUInt32(string address, ushort length)
 {
     return(ByteTransformHelper.GetResultFromBytes(Read(address, (ushort)(length * WordLength * 2)), m => ByteTransform.TransUInt32(m, 0, length)));
 }

Example #30

 /// <summary>
 /// 读取设备的short类型的数据
 /// </summary>
 /// <param name="address">起始地址</param>
 /// <returns>带成功标志的结果数据对象</returns>
 public OperateResult <short> ReadInt16(string address)
 {
     return(ByteTransformHelper.GetInt16ResultFromBytes(Read(address, WordLength), byteTransform));
 }