package com.zy.common.HslCommunication.Core.Net.NetworkBase;
|
|
import com.zy.common.HslCommunication.BasicFramework.SoftBasic;
|
import com.zy.common.HslCommunication.Core.IMessage.INetMessage;
|
import com.zy.common.HslCommunication.Core.Net.IReadWriteNet;
|
import com.zy.common.HslCommunication.Core.Transfer.IByteTransform;
|
import com.zy.common.HslCommunication.Core.Types.IDataTransfer;
|
import com.zy.common.HslCommunication.Core.Types.OperateResult;
|
import com.zy.common.HslCommunication.Core.Types.OperateResultExOne;
|
import com.zy.common.HslCommunication.Utilities;
|
|
|
/**
|
* 设备类的基类，提供了基础的字节读写方法，采用泛型继承实现
|
* @param <TNetMessage> 消息类型
|
* @param <TTransform> 变换类型
|
*/
|
public class NetworkDeviceBase<TNetMessage extends INetMessage,TTransform extends IByteTransform> extends NetworkDoubleBase<TNetMessage,TTransform> implements IReadWriteNet
|
{
|
|
|
|
/**************************************************************************************************
|
*
|
* 说明：子类中需要重写基础的读取和写入方法，来支持不同的数据访问规则
|
*
|
* 此处没有将读写位纳入进来，因为各种设备的支持不尽相同，比较麻烦
|
*
|
**************************************************************************************************/
|
|
protected short WordLength = 1;
|
|
|
/**
|
* 从设备读取原始数据
|
* @param address 地址信息
|
* @param length 数据长度
|
* @return 带有成功标识的结果对象
|
*/
|
public OperateResultExOne<byte[]> Read(String address, short length) {
|
return new OperateResultExOne<byte[]>();
|
}
|
|
|
/**
|
* 将原始数据写入设备
|
* @param address 起始地址
|
* @param value 原始数据
|
* @return 带有成功标识的结果对象
|
*/
|
public OperateResult Write(String address, byte[] value) {
|
return new OperateResult();
|
}
|
|
|
|
|
|
/**
|
* 读取自定义类型的数据，需要规定解析规则
|
* @param address 起始地址
|
* @param tClass 类
|
* @param <T> 类型名称
|
* @return 带有成功标识的结果对象
|
*/
|
public <T extends IDataTransfer> OperateResultExOne<T> ReadCustomer(String address ,Class<T> tClass)
|
{
|
OperateResultExOne<T> result = new OperateResultExOne<T>();
|
T Content;
|
try {
|
Content = tClass.newInstance();
|
}
|
catch (Exception ex){
|
Content = null;
|
}
|
OperateResultExOne<byte[]> read = Read(address, Content.getReadCount());
|
if (read.IsSuccess) {
|
Content.ParseSource(read.Content);
|
result.Content = Content;
|
result.IsSuccess = true;
|
} else {
|
result.ErrorCode = read.ErrorCode;
|
result.Message = read.Message;
|
}
|
return result;
|
}
|
|
|
/**
|
* 写入自定义类型的数据到设备去，需要规定生成字节的方法
|
* @param address 起始地址
|
* @param data 实例对象
|
* @param <T> 自定义类型
|
* @return 带有成功标识的结果对象
|
*/
|
public <T extends IDataTransfer> OperateResult WriteCustomer(String address, T data )
|
{
|
return Write(address, data.ToSource());
|
}
|
|
|
/**
|
* 读取设备的short类型的数据
|
* @param address 起始地址
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<Short> ReadInt16(String address) {
|
return GetInt16ResultFromBytes(Read(address, WordLength));
|
}
|
|
|
/**
|
* 读取设备的short类型的数组
|
* @param address 起始地址
|
* @param length 读取的数组长度
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<short[]> ReadInt16(String address, short length) {
|
OperateResultExOne<byte[]> read = Read(address, (short) (length * WordLength));
|
if (!read.IsSuccess) {
|
OperateResultExOne<short[]> result = new OperateResultExOne<short[]>();
|
result.CopyErrorFromOther(read);
|
return result;
|
}
|
return OperateResultExOne.CreateSuccessResult(super.getByteTransform().TransInt16(read.Content, 0, length));
|
}
|
|
|
|
/**
|
* 读取设备的int类型的数据
|
* @param address 起始地址
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<Integer> ReadInt32(String address) {
|
return GetInt32ResultFromBytes(Read(address, (short) (2 * WordLength)));
|
}
|
|
|
|
/**
|
* 读取设备的int类型的数组
|
* @param address 起始地址
|
* @param length 数组长度
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<int[]> ReadInt32(String address, short length) {
|
OperateResultExOne<byte[]> read = Read(address, (short) (length * WordLength * 2));
|
if (!read.IsSuccess) {
|
OperateResultExOne<int[]> result = new OperateResultExOne<int[]>();
|
result.CopyErrorFromOther(read);
|
return result;
|
}
|
return OperateResultExOne.CreateSuccessResult(super.getByteTransform().TransInt32(read.Content, 0, length));
|
}
|
|
|
/**
|
* 读取设备的float类型的数据
|
* @param address 起始地址
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<Float> ReadFloat(String address) {
|
return GetSingleResultFromBytes(Read(address, (short) (2 * WordLength)));
|
}
|
|
|
|
/**
|
* 读取设备的float类型的数组
|
* @param address 起始地址
|
* @param length 数组长度
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<float[]> ReadFloat(String address, short length) {
|
OperateResultExOne<byte[]> read = Read(address, (short) (length * WordLength * 2));
|
if (!read.IsSuccess) {
|
OperateResultExOne<float[]> result = new OperateResultExOne<float[]>();
|
result.CopyErrorFromOther(read);
|
return result;
|
}
|
return OperateResultExOne.CreateSuccessResult(super.getByteTransform().TransSingle(read.Content, 0, length));
|
}
|
|
|
|
/**
|
* 读取设备的long类型的数据
|
* @param address 起始地址
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<Long> ReadInt64(String address) {
|
return GetInt64ResultFromBytes(Read(address, (short) (4 * WordLength)));
|
}
|
|
|
/**
|
* 读取设备的long类型的数组
|
* @param address 起始地址
|
* @param length 数组长度
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<long[]> ReadInt64(String address, short length) {
|
OperateResultExOne<byte[]> read = Read(address, (short) (length * WordLength * 4));
|
if (!read.IsSuccess) {
|
OperateResultExOne<long[]> result = new OperateResultExOne<long[]>();
|
result.CopyErrorFromOther(read);
|
return result;
|
}
|
return OperateResultExOne.CreateSuccessResult(super.getByteTransform().TransInt64(read.Content, 0, length));
|
}
|
|
|
|
/**
|
* 读取设备的double类型的数据
|
* @param address 起始地址
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<Double> ReadDouble(String address) {
|
return GetDoubleResultFromBytes(Read(address, (short) (4 * WordLength)));
|
}
|
|
|
|
/**
|
* 读取设备的double类型的数组
|
* @param address 起始地址
|
* @param length 数组长度
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<double[]> ReadDouble(String address, short length) {
|
OperateResultExOne<byte[]> read = Read(address, (short) (length * WordLength * 4));
|
if (!read.IsSuccess) {
|
OperateResultExOne<double[]> result = new OperateResultExOne<double[]>();
|
result.CopyErrorFromOther(read);
|
return result;
|
}
|
return OperateResultExOne.CreateSuccessResult(super.getByteTransform().TransDouble(read.Content, 0, length));
|
}
|
|
|
|
/**
|
* 读取设备的字符串数据，编码为ASCII
|
* @param address 起始地址
|
* @param length 数据长度
|
* @return 带成功标志的结果数据对象
|
*/
|
public OperateResultExOne<String> ReadString(String address, short length) {
|
return GetStringResultFromBytes(Read(address, length));
|
}
|
|
|
|
|
|
|
/**
|
* 向设备中写入short数组，返回是否写入成功
|
* @param address 起始地址
|
* @param values 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, short[] values) {
|
return Write(address, super.getByteTransform().TransByte(values));
|
}
|
|
|
|
/**
|
* 向设备中写入short数据，返回是否写入成功
|
* @param address 起始地址
|
* @param value 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, short value) {
|
return Write(address, new short[]{value});
|
}
|
|
|
|
|
|
/**
|
* 向设备中写入int数组，返回是否写入成功
|
* @param address 起始地址
|
* @param values 写入值
|
* @return 返回写入结果
|
*/
|
/// <returns>返回写入结果</returns>
|
public OperateResult Write(String address, int[] values) {
|
return Write(address, super.getByteTransform().TransByte(values));
|
}
|
|
/**
|
* 向设备中写入int数据，返回是否写入成功
|
* @param address 起始地址
|
* @param value 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, int value) {
|
return Write(address, new int[]{value});
|
}
|
|
|
|
|
/**
|
* 向设备中写入float数组，返回是否写入成功
|
* @param address 起始地址
|
* @param values 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, float[] values) {
|
return Write(address, super.getByteTransform().TransByte(values));
|
}
|
|
|
/**
|
* 向设备中写入float数据，返回是否写入成功
|
* @param address 起始地址
|
* @param value 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, float value) {
|
return Write(address, new float[]{value});
|
}
|
|
|
|
/**
|
* 向设备中写入long数组，返回是否写入成功
|
* @param address 起始地址
|
* @param values 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, long[] values) {
|
return Write(address, getByteTransform().TransByte(values));
|
}
|
|
|
/**
|
* 向设备中写入long数据，返回是否写入成功
|
* @param address 起始地址
|
* @param value 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, long value) {
|
return Write(address, new long[]{value});
|
}
|
|
|
|
|
|
/**
|
* 设备中写入double数组，返回是否写入成功
|
* @param address 起始地址
|
* @param values 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, double[] values) {
|
return Write(address, getByteTransform().TransByte(values));
|
}
|
|
|
/**
|
* 向设备中写入double数据，返回是否写入成功
|
* @param address 起始地址
|
* @param value 写入值
|
* @return 返回写入结果
|
*/
|
public OperateResult Write(String address, double value) {
|
return Write(address, new double[]{value});
|
}
|
|
|
|
/**
|
* 向设备中写入字符串，编码格式为ASCII
|
* @param address 起始地址
|
* @param value 写入值
|
* @return 返回读取结果
|
*/
|
public OperateResult Write(String address, String value) {
|
byte[] temp = getByteTransform().TransByte(value, "US-ASCII");
|
if (WordLength == 1) temp = SoftBasic.ArrayExpandToLengthEven(temp);
|
return Write(address, temp);
|
}
|
|
|
/**
|
* 向设备中写入字符串，编码格式为ASCII
|
* @param address 起始地址
|
* @param value 写入值
|
* @param length 写入的字符串的长度
|
* @return 返回读取结果
|
*/
|
public OperateResult Write(String address, String value, int length) {
|
byte[] temp = getByteTransform().TransByte(value, "US-ASCII");
|
temp = SoftBasic.ArrayExpandToLength(temp, length);
|
if (WordLength == 1) temp = SoftBasic.ArrayExpandToLengthEven(temp);
|
return Write(address, temp);
|
}
|
|
|
|
/**
|
* 向设备中写入字符串，编码格式为Unicode
|
* @param address 要写入的数据地址
|
* @param value 要写入的实际数据
|
* @return 写入结果
|
*/
|
public OperateResult WriteUnicodeString(String address, String value) {
|
byte[] temp = Utilities.string2Byte(value);
|
return Write(address, temp);
|
}
|
|
|
/**
|
* 向设备中写入字符串，超出截断，不够补0，编码格式为Unicode
|
* @param address 要写入的数据地址
|
* @param value 要写入的实际数据
|
* @param length 指定的字符串长度，必须大于0
|
* @return 写入结果
|
*/
|
public OperateResult WriteUnicodeString(String address, String value, int length) {
|
byte[] temp = Utilities.string2Byte(value);
|
temp = SoftBasic.ArrayExpandToLength(temp, length * 2);
|
return Write(address, temp);
|
}
|
|
|
/**
|
* 返回表示当前对象的字符串
|
* @return 字符串数据
|
*/
|
@Override
|
public String toString() {
|
return "NetworkDeviceBase<TNetMessage, TTransform>";
|
}
|
|
}
|
