Sic-Software
/
Sic.Framework-Nanjing-Baishi
4
0
Fork 0
Code Issues Pull Requests Projects Releases Activity
Sic.Framework-Nanjing-Baishi/MECF.Framework.RT.Core/IoProviders/Siemens/Serial/SerialDeviceBase.cs

637 lines
24 KiB
C#
Raw Normal View History

Add project files.
2023-04-13 11:51:03 +08:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MECF.Framework.RT.Core.IoProviders.Siemens.Net;
using MECF.Framework.RT.Core.IoProviders.Siemens.Transfer;
namespace MECF.Framework.RT.Core.IoProviders.Siemens.Serial
{
/// <summary>
/// 基于串口的设备交互类的对象，需要从本类继承，然后实现不同的设备读写操作。
/// </summary>
/// <typeparam name="TTransform">数据解析的规则泛型</typeparam>
public class SerialDeviceBase<TTransform> : SerialBase, IReadWriteNet where TTransform : IByteTransform, new()
{
#region Constructor
/// <summary>
/// 默认的构造方法实现的设备信息
/// </summary>
public SerialDeviceBase( )
{
byteTransform = new TTransform( ); // 实例化数据转换规则
}
#endregion
#region Virtual Method
/**************************************************************************************************
*
* 说明：子类中需要重写基础的读取和写入方法，来支持不同的数据访问规则
*
* 此处没有将读写位纳入进来，因为各种设备的支持不尽相同，比较麻烦
*
**************************************************************************************************/
/// <summary>
/// 从设备读取原始数据
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">地址长度</param>
/// <returns>带有成功标识的结果对象</returns>
/// <remarks>需要在继承类中重写实现，并且实现地址解析操作</remarks>
public virtual OperateResult<byte[]> Read( string address, ushort length )
{
return new OperateResult<byte[]>( );
}
/// <summary>
/// 将原始数据写入设备
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="value">原始数据</param>
/// <returns>带有成功标识的结果对象</returns>
/// <remarks>需要在继承类中重写实现，并且实现地址解析操作</remarks>
public virtual OperateResult Write( string address, byte[] value )
{
return new OperateResult( );
}
#endregion
#region Protect Member
/// <summary>
/// 单个数据字节的长度，西门子为2，三菱，欧姆龙，modbusTcp就为1
/// </summary>
/// <remarks>对设备来说，一个地址的数据对应的字节数，或是1个字节或是2个字节</remarks>
protected ushort WordLength { get; set; } = 1;
#endregion
#region Public Member
/// <summary>
/// 当前客户端的数据变换机制，当你需要从字节数据转换类型数据的时候需要。
/// </summary>
/// <example>
/// 主要是用来转换数据类型的，下面仅仅演示了2个方法，其他的类型转换，类似处理。
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDoubleBase.cs" region="ByteTransform" title="ByteTransform示例" />
/// </example>
public TTransform ByteTransform
{
get { return byteTransform; }
set { byteTransform = value; }
}
/// <summary>
/// 当前连接的唯一ID号，默认为长度20的guid码加随机数组成，方便列表管理，也可以自己指定
/// </summary>
/// <remarks>
/// Current Connection ID, conclude guid and random data, also, you can spcified
/// </remarks>
public string ConnectionId
{
get { return connectionId; }
set { connectionId = value; }
}
#endregion
#region Customer Support
/// <summary>
/// 读取自定义类型的数据，需要规定解析规则
/// </summary>
/// <typeparam name="T">类型名称</typeparam>
/// <param name="address">起始地址</param>
/// <returns>带有成功标识的结果对象</returns>
/// <remarks>
/// 需要是定义一个类，选择好相对于的ByteTransform实例，才能调用该方法。
/// </remarks>
public OperateResult<T> ReadCustomer<T>( string address ) where T : IDataTransfer, new()
{
OperateResult<T> result = new OperateResult<T>( );
T Content = new T( );
OperateResult<byte[]> read = Read( address, Content.ReadCount );
if (read.IsSuccess)
{
Content.ParseSource( read.Content );
result.Content = Content;
result.IsSuccess = true;
}
else
{
result.ErrorCode = read.ErrorCode;
result.Message = read.Message;
}
return result;
}
/// <summary>
/// 写入自定义类型的数据到设备去，需要规定生成字节的方法
/// </summary>
/// <typeparam name="T">自定义类型</typeparam>
/// <param name="address">起始地址</param>
/// <param name="data">实例对象</param>
/// <returns>带有成功标识的结果对象</returns>
/// <remarks>
/// 需要是定义一个类，选择好相对于的<see cref="IDataTransfer"/>实例，才能调用该方法。
/// </remarks>
public OperateResult WriteCustomer<T>( string address, T data ) where T : IDataTransfer, new()
{
return Write( address, data.ToSource( ) );
}
#endregion
#region Read Support
/// <summary>
/// 读取设备的short类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<short> ReadInt16( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadInt16( address, 1 ) );
}
/// <summary>
/// 读取设备的short类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<short[]> ReadInt16( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength) ), m => ByteTransform.TransInt16( m, 0, length ) );
}
/// <summary>
/// 读取设备的ushort数据类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<ushort> ReadUInt16( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadUInt16( address, 1 ) );
}
/// <summary>
/// 读取设备的ushort类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<ushort[]> ReadUInt16( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength) ), m => ByteTransform.TransUInt16( m, 0, length ) );
}
/// <summary>
/// 读取设备的int类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<int> ReadInt32( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadInt32( address, 1 ) );
}
/// <summary>
/// 读取设备的int类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<int[]> ReadInt32( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 2) ), m => ByteTransform.TransInt32( m, 0, length ) );
}
/// <summary>
/// 读取设备的uint类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<uint> ReadUInt32( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadUInt32( address, 1 ) );
}
/// <summary>
/// 读取设备的uint类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<uint[]> ReadUInt32( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 2) ), m => ByteTransform.TransUInt32( m, 0, length ) );
}
/// <summary>
/// 读取设备的float类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<float> ReadFloat( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadFloat( address, 1 ) );
}
/// <summary>
/// 读取设备的float类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<float[]> ReadFloat( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 2) ), m => ByteTransform.TransSingle( m, 0, length ) );
}
/// <summary>
/// 读取设备的long类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<long> ReadInt64( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadInt64( address, 1 ) );
}
/// <summary>
/// 读取设备的long类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<long[]> ReadInt64( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 4) ), m => ByteTransform.TransInt64( m, 0, length ) );
}
/// <summary>
/// 读取设备的ulong类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<ulong> ReadUInt64( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadUInt64( address, 1 ) );
}
/// <summary>
/// 读取设备的ulong类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<ulong[]> ReadUInt64( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 4) ), m => ByteTransform.TransUInt64( m, 0, length ) );
}
/// <summary>
/// 读取设备的double类型的数据
/// </summary>
/// <param name="address">起始地址</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<double> ReadDouble( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadDouble( address, 1 ) );
}
/// <summary>
/// 读取设备的double类型的数组
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">数组长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<double[]> ReadDouble( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 4) ), m => ByteTransform.TransDouble( m, 0, length ) );
}
/// <summary>
/// 读取设备的字符串数据，编码为ASCII
/// </summary>
/// <param name="address">起始地址</param>
/// <param name="length">地址长度</param>
/// <returns>带成功标志的结果数据对象</returns>
public OperateResult<string> ReadString( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, length ), m => ByteTransform.TransString( m, 0, m.Length, Encoding.ASCII ) );
}
#endregion
#region Write Int16
/// <summary>
/// 向设备中写入short数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, short[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入short数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, short value )
{
return Write( address, new short[] { value } );
}
#endregion
#region Write UInt16
/// <summary>
/// 向设备中写入ushort数组，返回是否写入成功
/// </summary>
/// <param name="address">要写入的数据地址</param>
/// <param name="values">要写入的实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, ushort[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入ushort数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, ushort value )
{
return Write( address, new ushort[] { value } );
}
#endregion
#region Write Int32
/// <summary>
/// 向设备中写入int数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, int[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入int数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, int value )
{
return Write( address, new int[] { value } );
}
#endregion
#region Write UInt32
/// <summary>
/// 向设备中写入uint数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, uint[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入uint数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, uint value )
{
return Write( address, new uint[] { value } );
}
#endregion
#region Write Float
/// <summary>
/// 向设备中写入float数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, float[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入float数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, float value )
{
return Write( address, new float[] { value } );
}
#endregion
#region Write Int64
/// <summary>
/// 向设备中写入long数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, long[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入long数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, long value )
{
return Write( address, new long[] { value } );
}
#endregion
#region Write UInt64
/// <summary>
/// 向P设备中写入ulong数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, ulong[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入ulong数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, ulong value )
{
return Write( address, new ulong[] { value } );
}
#endregion
#region Write Double
/// <summary>
/// 向设备中写入double数组，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="values">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, double[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
/// <summary>
/// 向设备中写入double数据，返回是否写入成功
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">实际数据</param>
/// <returns>返回写入结果</returns>
public virtual OperateResult Write( string address, double value )
{
return Write( address, new double[] { value } );
}
#endregion
#region Write String
/// <summary>
/// 向设备中写入字符串，编码格式为ASCII
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">字符串数据</param>
/// <returns>是否写入成功的结果对象</returns>
/// <example>
/// 以下为三菱的连接对象示例，其他的设备读写情况参照下面的代码：
/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Core\NetworkDeviceBase.cs" region="WriteString" title="String类型示例" />
/// </example>
public virtual OperateResult Write( string address, string value )
{
byte[] temp = ByteTransform.TransByte( value, Encoding.ASCII );
if (WordLength == 1) temp = SoftBasic.ArrayExpandToLengthEven( temp );
return Write( address, temp );
}
/// <summary>
/// 向设备中写入指定长度的字符串,超出截断，不够补0，编码格式为ASCII
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">字符串数据</param>
/// <param name="length">指定的字符串长度，必须大于0</param>
/// <returns>是否写入成功的结果对象 -> Whether to write a successful result object</returns>
public virtual OperateResult Write( string address, string value, int length )
{
byte[] temp = ByteTransform.TransByte( value, Encoding.ASCII );
if (WordLength == 1) temp = SoftBasic.ArrayExpandToLengthEven( temp );
temp = SoftBasic.ArrayExpandToLength( temp, length );
return Write( address, temp );
}
/// <summary>
/// 向设备中写入字符串，编码格式为Unicode
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">字符串数据</param>
/// <returns>是否写入成功的结果对象</returns>
public virtual OperateResult WriteUnicodeString( string address, string value )
{
byte[] temp = ByteTransform.TransByte( value, Encoding.Unicode );
return Write( address, temp );
}
/// <summary>
/// 向设备中写入指定长度的字符串,超出截断，不够补0，编码格式为Unicode
/// </summary>
/// <param name="address">数据地址</param>
/// <param name="value">字符串数据</param>
/// <param name="length">指定的字符串长度，必须大于0</param>
/// <returns>是否写入成功的结果对象 -> Whether to write a successful result object</returns>
public virtual OperateResult WriteUnicodeString( string address, string value, int length )
{
byte[] temp = ByteTransform.TransByte( value, Encoding.Unicode );
temp = SoftBasic.ArrayExpandToLength( temp, length * 2 );
return Write( address, temp );
}
#endregion
#region Private Member
private TTransform byteTransform; // 数据变换的接口
private string connectionId = string.Empty; // 当前连接
#endregion
#region Object Override
/// <summary>
/// 返回表示当前对象的字符串
/// </summary>
/// <returns>字符串数据</returns>
public override string ToString( )
{
return "SerialDeviceBase<TTransform>";
}
#endregion
}
}