public Item <ushort>[] ReadUShorts(DeviceAddress deviceAddress, ushort length)
{
var datas = readyBytes(deviceAddress, 2 * length);
var ushorts = UnsafeNetConvert.BytesToUShorts(datas, 0, length, deviceAddress.ByteOrder);
return(NetConvert.ToItems(ushorts, 0, length));
}
/// <summary>
/// Read Hold Register Rely
/// Fucntion:0x03
/// </summary>
/// <param name="address">40001~49999</param>
/// <param name="count">less than 128</param>
/// <returns></returns>
private byte[] readHoldRegisterRely(int address, int count)
{
byte[] dataBuffer = new byte[count * 2];
byte[] relyBuffer = new byte[count * 2 + 3]; //addtion SlaveId，Function,Count
IPointMapping <ushort> _ushortMapping = _mapping as IPointMapping <ushort>;
var ushortData = new ushort[count];
for (int i = 0; i < count; i++)
{
var addressString = string.Format("{0:D5}", address + i + 1 + 40000);//地址偏移+1
if (_mapping.Find(addressString))
{
ushortData[i] = _ushortMapping.GetValue(addressString)[0];
}
else
{
return(errorRely(FunctionCode.ReadHoldRegister, ErrorCode.LllegalDataAddress));
};
}
dataBuffer = UnsafeNetConvert.UShortsToBytes(ushortData, ByteOrder.BigEndian);
relyBuffer[0] = (byte)_salveId;
relyBuffer[1] = (byte)FunctionCode.ReadHoldRegister;
relyBuffer[2] = (byte)dataBuffer.Length;
Array.Copy(dataBuffer, 0, relyBuffer, 3, dataBuffer.Length);
return(relyBuffer);
}
public Item <float>[] Readfloats(DeviceAddress deviceAddress, ushort length)
{
var datas = readRegister(deviceAddress, 2 * length);
var bdatas = UnsafeNetConvert.BytesToFloats(datas, 0, length, deviceAddress.ByteOrder);
return(NetConvert.ToItems(bdatas, 0, length));
}
public Item <int>[] ReadInts(DeviceAddress deviceAddress, ushort length)
{
var datas = readyBytes(deviceAddress, 4 * length);
var ints = UnsafeNetConvert.BytesToInts(datas, 0, length, deviceAddress.ByteOrder);
return(NetConvert.ToItems(ints, 0, length));
}
public int WriteUShorts(DeviceAddress deviceAddress, ushort[] datas)
{
lock (_async)
{
_handler = _handler++ >= 65535 ? 0 : _handler;
var source = createWriteHeader(deviceAddress, _handler, UnsafeNetConvert.UShortsToBytes(datas, ByteOrder.BigEndian));
return(writedata(deviceAddress, source));
}
}
public Item <ushort> ReadUShort(DeviceAddress deviceAddress)
{
var datas = readRegister(deviceAddress, 1);
return(datas == null ? Item <ushort> .CreateDefault() :
new Item <ushort>()
{
Vaule = UnsafeNetConvert.BytesToUShort(datas, 0, deviceAddress.ByteOrder), UpdateTime = DateTime.Now, Quality = QUALITIES.QUALITY_GOOD
});
}
public Item <int> ReadInt(DeviceAddress deviceAddress)
{
var datas = readyBytes(deviceAddress, 4);
return(datas == null ? Item <int> .CreateDefault() :
new Item <int>()
{
Vaule = UnsafeNetConvert.BytesToInt(datas, 0, deviceAddress.ByteOrder), UpdateTime = DateTime.Now, Quality = QUALITIES.QUALITY_GOOD
});
}
/// <summary>
/// 16位无符号整形点绑定16位整形数据
/// </summary>
/// <param name="source">16位整形源数据</param>
/// <param name="sourceindex">源数据点索引</param>
/// <param name="target">目标数据，点长度为1的虚拟点</param>
/// <param name="bindingWay">绑定方式，默认为单方向</param>
public static bool UshortBinding(IPoint <short> source, int sourceindex, IPoint <ushort> target, BindingWay bindingWay = BindingWay.OneWay)
{
if (sourceindex >= source.Length)
{
return(false);
}
switch (bindingWay)
{
case BindingWay.OneWay:
source.PropertyChanged += (s, p) =>
{
if (int.Parse(p.PropertyName) == sourceindex)
{
byte[] temp1 = UnsafeNetConvert.ShortToBytes(source[(byte)sourceindex], ByteOrder.None);
ushort temp2 = UnsafeNetConvert.BytesToUShort(temp1, 0, ByteOrder.None);
target.ValueUpdate(temp2, 0);
}
};
return(true);
case BindingWay.TwoWay:
source.PropertyChanged += (s, p) =>
{
if (int.Parse(p.PropertyName) == sourceindex)
{
byte[] temp1 = UnsafeNetConvert.ShortToBytes(source[(byte)sourceindex], ByteOrder.None);
ushort temp2 = UnsafeNetConvert.BytesToUShort(temp1, 0, ByteOrder.None);
target.ValueUpdate(temp2, 0);
}
};
target.PropertyChanged += (s, p) =>
{
var temp1 = UnsafeNetConvert.UShortToBytes(target[0], ByteOrder.None);
var temp2 = UnsafeNetConvert.BytesToShort(temp1, 0, ByteOrder.None);
source.ValueUpdate(temp2, sourceindex);
};
return(true);
case BindingWay.ReverseWay:
target.PropertyChanged += (s, p) =>
{
var temp1 = UnsafeNetConvert.UShortToBytes(target[0], ByteOrder.None);
var temp2 = UnsafeNetConvert.BytesToShort(temp1, 0, ByteOrder.None);
source.ValueUpdate(temp2, sourceindex);
};
return(true);
default:
return(false);
}
}
public int WriteUShorts(DeviceAddress deviceAddress, ushort[] datas)
{
ushort startAddress;
if (Function.EnableWriteRegister(deviceAddress.Address, out startAddress))
{
byte[] valueBytes = UnsafeNetConvert.BytesPerversion(UnsafeNetConvert.UShortsToBytes(datas, deviceAddress.ByteOrder));
byte[] sendBytes = getWriteMulRegisterHeader((byte)deviceAddress.SalveId, startAddress, valueBytes);
return(writeBytes(sendBytes));
}
else
{
return(-1);
}
}
public int WriteFloat(DeviceAddress deviceAddress, float datas)
{
ushort startAddress;
if (Function.EnableWriteRegister(deviceAddress.Address, out startAddress))
{
var valueBytes = (deviceAddress.ByteOrder == ByteOrder.BigEndian) ? UnsafeNetConvert.FloatToBytes(datas, deviceAddress.ByteOrder)
: UnsafeNetConvert.BytesPerversion(UnsafeNetConvert.FloatToBytes(datas, deviceAddress.ByteOrder));
byte[] sendBytes = getWriteMulRegisterHeader((byte)deviceAddress.SalveId, startAddress, valueBytes);
return(writeBytes(sendBytes));
}
else
{
return(-1);
}
}
private byte[] readRegister(DeviceAddress deviceAddress, int lenght)
{
byte salveID = (byte)deviceAddress.SalveId;
ushort startAddress;
byte funcCode = (byte)Function.GetReadFunctionCode(deviceAddress.Address, out startAddress);
if (funcCode == 3 || funcCode == 4)
{
//若byteOrder为bigEndian不需要颠倒word高低位
return((deviceAddress.ByteOrder == ByteOrder.BigEndian)? readBytes(salveID, startAddress, funcCode, (ushort)lenght)
: UnsafeNetConvert.BytesPerversion(readBytes(salveID, startAddress, funcCode, (ushort)lenght)));
}
else
{
return(null);
}
}
/// <summary>
/// Write single hold reister Rely
/// Function:0x06
/// </summary>
/// <param name="address">40001~49999</param>
/// <param name="data">length=2,Data Hi:data[0],Data Lo:data[1]</param>
/// <returns></returns>
private byte[] writeSingleReisterRely(int address, byte[] data)
{
byte[] relyBuffer = new byte[6];
var value = UnsafeNetConvert.BytesToUShort(data, 0, ByteOrder.BigEndian);
var addressString = string.Format("{0:D5}", address + 1 + 40000); //地址偏移+1
if (_mapping.SetValue(addressString, new ushort[] { value }) == -1)
{
return(errorRely(FunctionCode.WriteSingleRegister, ErrorCode.LllegalDataAddress));
}
relyBuffer[0] = (byte)_salveId;
relyBuffer[1] = (byte)FunctionCode.WriteSingleRegister;
var addrByte = UnsafeNetConvert.UShortToBytes((ushort)address, ByteOrder.BigEndian);
Array.Copy(addrByte, 0, relyBuffer, 2, 2);
Array.Copy(data, 0, relyBuffer, 4, data.Length);
return(relyBuffer);
}
/// <summary>
/// Force Multi Coils Rely
/// Function:0x0F
/// </summary>
/// <param name="address">00001～09999</param>
/// <param name="data"></param>
/// <param name="count">bools count of byte array</param>
/// <returns></returns>
private byte[] writeMulColilRely(int address, byte[] data, int count)
{
byte[] relyBuffer = new byte[6];
var values = NetConvert.BytesToBools(data, count);
for (int i = 0; i < count; i++)
{
var addressString = string.Format("{0:D5}", address + i + 1);//地址偏移+1
if (_mapping.SetValue(addressString, new bool[] { values[i] }) == -1)
{
return(errorRely(FunctionCode.ForceMulCoil, ErrorCode.LllegalDataAddress));
}
}
relyBuffer[0] = (byte)_salveId;
relyBuffer[1] = (byte)FunctionCode.ForceMulCoil;
var addrByte = UnsafeNetConvert.UShortToBytes((ushort)address, ByteOrder.BigEndian);
Array.Copy(addrByte, 0, relyBuffer, 2, 2);
var countByte = UnsafeNetConvert.UShortToBytes((ushort)count, ByteOrder.BigEndian);
Array.Copy(countByte, 0, relyBuffer, 4, 2);
return(relyBuffer);
}
/// <summary>
/// Force Single Coil Value
/// Function:0x05
/// </summary>
/// <param name="address">00001~09999</param>
/// <param name="data">Length=2,data[0]=0xFF as true</param>
/// <returns></returns>
private byte[] writeSingleCoilRely(int address, byte[] data)
{
byte[] relyBuffer = new byte[6];
var addressString = string.Format("{0:D5}", address + 1);//地址偏移+1
bool[] value = new bool[1];
if (data[0] == 0xff)
{
value[0] = true;
}
if (_mapping.SetValue(addressString, value) == -1)
{
return(errorRely(FunctionCode.ForceSingleCoil, ErrorCode.LllegalDataAddress));
}
relyBuffer[0] = (byte)_salveId;
relyBuffer[1] = (byte)FunctionCode.ForceSingleCoil;
var addrByte = UnsafeNetConvert.UShortToBytes((ushort)address, ByteOrder.BigEndian);
Array.Copy(addrByte, 0, relyBuffer, 2, 2);
relyBuffer[4] = data[0];
relyBuffer[5] = data[1];
return(relyBuffer);
}
/// <summary>
/// 16位无符号整形点绑定32整形数据
/// </summary>
/// <param name="source">32位整形源数据</param>
/// <param name="sourceindex">源数据点索引</param>
/// <param name="targets">目标数据，数组长度为2，点长度为1的虚拟点</param>
/// <param name="bindingWay">绑定方式，默认为单方向</param>
public static bool UshortBinding(IPoint <int> source, int sourceindex, IPoint <ushort>[] targets, ByteOrder byterOrder = ByteOrder.None, BindingWay bindingWay = BindingWay.OneWay)
{
if (sourceindex >= source.Length)
{
return(false);
}
if (targets.Length != 2)
{
return(false);
}
switch (bindingWay)
{
case BindingWay.OneWay:
source.PropertyChanged += (s, p) =>
{
if (int.Parse(p.PropertyName) == sourceindex)
{
byte[] temp1 = UnsafeNetConvert.IntToBytes(source[(byte)sourceindex], byterOrder);
ushort[] temp2 = (byterOrder == ByteOrder.BigEndian)? UnsafeNetConvert.BytesToUShorts(temp1, 0, 2, byterOrder):UnsafeNetConvert.BytesToUShorts(temp1, 0, 2, ByteOrder.None);
for (int i = 0; i < targets.Length; i++)
{
targets[i].ValueUpdate(temp2[i], 0);
}
}
};
return(true);
case BindingWay.TwoWay:
source.PropertyChanged += (s, p) =>
{
if (int.Parse(p.PropertyName) == sourceindex)
{
byte[] temp1 = UnsafeNetConvert.IntToBytes(source[(byte)sourceindex], byterOrder);
ushort[] temp2 = (byterOrder == ByteOrder.BigEndian) ? UnsafeNetConvert.BytesToUShorts(temp1, 0, 2, byterOrder) : UnsafeNetConvert.BytesToUShorts(temp1, 0, 2, ByteOrder.None);
for (int i = 0; i < targets.Length; i++)
{
targets[i].ValueUpdate(temp2[i], 0);
}
}
};
foreach (var target in targets)
{
target.PropertyChanged += (s, p) =>
{
var temp1 = (byterOrder == ByteOrder.BigEndian) ? UnsafeNetConvert.UShortsToBytes(new ushort[] { targets[0][0], targets[1][0] }, byterOrder): UnsafeNetConvert.UShortsToBytes(new ushort[] { targets[0][0], targets[1][0] }, ByteOrder.None);
var temp2 = UnsafeNetConvert.BytesToInt(temp1, 0, byterOrder);
source.ValueUpdate(temp2, sourceindex);
};
}
return(true);
case BindingWay.ReverseWay:
foreach (var target in targets)
{
target.PropertyChanged += (s, p) =>
{
var temp1 = (byterOrder == ByteOrder.BigEndian) ? UnsafeNetConvert.UShortsToBytes(new ushort[] { targets[0][0], targets[1][0] }, byterOrder) : UnsafeNetConvert.UShortsToBytes(new ushort[] { targets[0][0], targets[1][0] }, ByteOrder.None);
var temp2 = UnsafeNetConvert.BytesToInt(temp1, 0, byterOrder);
source.ValueUpdate(temp2, sourceindex);
};
}
return(true);
default:
return(false);
}
}
private byte[] bufferRely(byte[] buffer)
{
byte[] getBuffer = null;
try
{
if (buffer[0] == (byte)_salveId)
{
switch ((FunctionCode)buffer[1])
{
case FunctionCode.ReadCoil:
if (buffer.Length < 6)
{
getBuffer = errorRely(FunctionCode.ReadCoil, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var count = UnsafeNetConvert.BytesToShort(buffer, 4, ByteOrder.BigEndian);
getBuffer = readCoilRely(startAddress, count);
}
break;
case FunctionCode.ReadInputStatus:
if (buffer.Length < 6)
{
getBuffer = errorRely(FunctionCode.ReadInputStatus, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var count = UnsafeNetConvert.BytesToShort(buffer, 4, ByteOrder.BigEndian);
getBuffer = readInStatusRely(startAddress, count);
}
break;
case FunctionCode.ReadInputRegister:
if (buffer.Length < 6)
{
getBuffer = errorRely(FunctionCode.ReadInputRegister, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var count = UnsafeNetConvert.BytesToShort(buffer, 4, ByteOrder.BigEndian);
getBuffer = readInputRegisterRely(startAddress, count);
}
break;
case FunctionCode.ReadHoldRegister:
if (buffer.Length < 6)
{
getBuffer = errorRely(FunctionCode.ReadHoldRegister, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var count = UnsafeNetConvert.BytesToShort(buffer, 4, ByteOrder.BigEndian);
getBuffer = readHoldRegisterRely(startAddress, count);
}
break;
case FunctionCode.ForceSingleCoil:
if (buffer.Length < 6)
{
getBuffer = errorRely(FunctionCode.ForceSingleCoil, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var data = new byte[] { buffer[4], buffer[5] };
getBuffer = writeSingleCoilRely(startAddress, data);
}
break;
case FunctionCode.ForceMulCoil:
if (buffer.Length < 7 || buffer.Length < 7 + buffer[6])
{
getBuffer = errorRely(FunctionCode.ForceMulCoil, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var count = UnsafeNetConvert.BytesToShort(buffer, 4, ByteOrder.BigEndian);
var data = new byte[buffer[6]];
Array.Copy(buffer, 7, data, 0, buffer[6]);
getBuffer = writeMulColilRely(startAddress, data, count);
}
break;
case FunctionCode.WriteSingleRegister:
if (buffer.Length < 6)
{
getBuffer = errorRely(FunctionCode.WriteSingleRegister, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var data = new byte[] { buffer[4], buffer[5] };
getBuffer = writeSingleReisterRely(startAddress, data);
}
break;
case FunctionCode.WriteMulRegister:
if (buffer.Length < 7 || buffer.Length < 7 + buffer[6])
{
getBuffer = errorRely(FunctionCode.WriteMulRegister, ErrorCode.LllegalData);
}
else
{
var startAddress = UnsafeNetConvert.BytesToShort(buffer, 2, ByteOrder.BigEndian);
var data = new byte[buffer[6]];
Array.Copy(buffer, 7, data, 0, buffer[6]);
getBuffer = writeMultiReisterRely(startAddress, data);
}
break;
default:
getBuffer = errorRely((FunctionCode)buffer[1], ErrorCode.LllegalFuctionCode);
break;
}
}
}
catch (Exception ex)
{
Log.ErrorLog(string.Format("Modbus buffer Rely Error:{0}", ex.ToString()));
}
return(getBuffer);
}
