public IDataContainer Read(BinaryReader reader)
{
int count = reader.ReadInt32();
bool isOrdered = reader.ReadBoolean();
var data = Locator.CreateDataContainer();
var set = (IOrderedSet <IData, IData>)data;
if (!isOrdered)
{
for (int i = 0; i < count; i++)
{
IData key = keyPersist.Read(reader);
IData record = recordPersist.Read(reader);
set.Add(key, record);
}
}
else
{
KeyValuePair <IData, IData>[] orderedArray = new KeyValuePair <IData, IData> [count];
for (int i = 0; i < orderedArray.Length; i++)
{
IData key = keyPersist.Read(reader);
IData record = recordPersist.Read(reader);
orderedArray[i] = new KeyValuePair <IData, IData>(key, record);
}
set.AddOrdered(orderedArray, 0, orderedArray.Length);
}
return(data);
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] temp_requetData1 = new byte[12];
//读取客户端发送过来的数据
temp_requetData1 = SocketRead(newSocket, temp_requetData1.Length);
byte[] requetData = null;
//0x03写字 - 0x00 读位 0x01 读字 0x02写位 0x03写字
if (temp_requetData1[0] == 0x03)
{
var lenght = temp_requetData1[11] * 2 * 256 + temp_requetData1[10] * 2;
byte[] temp_requetData2 = new byte[lenght];
temp_requetData2 = SocketRead(newSocket, temp_requetData2.Length);
requetData = temp_requetData1.Concat(temp_requetData2).ToArray();
}
//0x02写位
else if (temp_requetData1[0] == 0x02)
{
var lenght = temp_requetData1[11] * 256 + temp_requetData1[10];
byte[] temp_requetData2 = new byte[lenght];
temp_requetData2 = SocketRead(newSocket, temp_requetData2.Length);
requetData = temp_requetData1.Concat(temp_requetData2).ToArray();
}
else
{
requetData = temp_requetData1;
}
//地址
var address = $"{requetData[8]}{requetData[9]}-{ requetData[5] * 256 + requetData[4]}";
var dataKey = $"{requetData[8]}{requetData[9]}";
var beginAddress = requetData[5] * 256 + requetData[4];
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(dataKey)) ?? new byte[65536];
switch (requetData[0])
{
//读位 0x01 位 0x00 字节
case 0x00:
{
//数据存储长度
var lenght = requetData[10] + requetData[11] * 256;
var value = dataPersist.Read(address);
//把存储的数据转为字节数组
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (string.IsNullOrWhiteSpace(value))
{
bytes = BitConverter.GetBytes(0);
}
//数据的字节长度
var dataLenght = (int)Math.Ceiling(lenght * 0.5);
// 响应报文总长度
byte[] responseData = new byte[2 + dataLenght];
DataConvert.StringToByteArray("80 00").CopyTo(responseData, 0);
if (lenght == 1)
{
var oldBitValue = byteArray[beginAddress / 2];
//一个字节存储两个点位数据
var bitOffset = beginAddress % 2;
if (bitOffset == 0)
{
responseData[2] = (oldBitValue & 0b00010000) != 0 ? (byte)0b00010000 : (byte)0b00000000;
}
else
{
responseData[2] = (oldBitValue & 0b00000001) != 0 ? (byte)0b00010000 : (byte)0b00000000;
}
}
else
{
Buffer.BlockCopy(byteArray, beginAddress / 2, responseData, 2, dataLenght);
}
newSocket.Send(responseData);
}
break;
//读字
case 0x01:
{
var addressLenght = 2;
//数据存储长度
var lenght = requetData[10] + requetData[11] * 256;
var value = dataPersist.Read(address);
//数据的字节长度
var dataLenght = lenght * 2;
// 响应报文总长度
byte[] responseData = new byte[2 + dataLenght];
DataConvert.StringToByteArray("81 00").CopyTo(responseData, 0);
Buffer.BlockCopy(byteArray, beginAddress * addressLenght, responseData, 2, dataLenght);
newSocket.Send(responseData);
}
break;
//写位 0x02写位 0x03写字
case 0x02:
{
////[12]后面存的是数据
var valueByte = new byte[requetData.Length - 12];
Buffer.BlockCopy(requetData, 12, valueByte, 0, valueByte.Length);
////一个字节存储两个点位数据
//valueByte.CopyTo(byteArray, beginAddress / 2);
var oldBitValue = byteArray[beginAddress / 2];
var bitOffset = beginAddress % 2; //一个字节存储两个点位数据
if (valueByte[0] == 0x10) //true
{
if (bitOffset == 0)
{
oldBitValue = (byte)(oldBitValue | 0b00010000);
}
else
{
oldBitValue = (byte)(oldBitValue | 0b00000001);
}
}
else //false
{
if (bitOffset == 0)
{
oldBitValue = (byte)(oldBitValue & ~0b11111110); //修改成0b00000001或0b00000000
}
else
{
oldBitValue = (byte)(oldBitValue & ~0b11101111); //修改成0b00010000或0b00000000
}
}
new byte[] { oldBitValue }.CopyTo(byteArray, beginAddress / 2);
//存储字节数据到内存
dataPersist.Write(dataKey, JsonConvert.SerializeObject(byteArray));
byte[] responseData1 = DataConvert.StringToByteArray("82 00");
newSocket.Send(responseData1);
}
break;
//写字
case 0x03:
{
var addressLenght = 2;
//[12]后面存的是数据
var valueByte = new byte[requetData.Length - 12];
Buffer.BlockCopy(requetData, 12, valueByte, 0, valueByte.Length);
valueByte.CopyTo(byteArray, beginAddress * addressLenght);
//存储字节数据到内存
dataPersist.Write(dataKey, JsonConvert.SerializeObject(byteArray));
byte[] responseData1 = DataConvert.StringToByteArray("83 00");
newSocket.Send(responseData1);
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收数据回调用
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DataReceived(object sender, SerialDataReceivedEventArgs e)
{
try
{
byte[] requetData = new byte[serialPort.BytesToRead];
serialPort.Read(requetData, 0, requetData.Length);
var address = requetData[2] * 256 + requetData[3];
var stationNumberKey = $"{requetData[0]}-key";//站号
switch (requetData[1])
{
//读取线圈
case 1:
{
var value = dataPersist.Read(stationNumberKey + "-Coil");
var byteArray = JsonConvert.DeserializeObject <byte[]>(value) ?? new byte[65536];
var registerLenght = requetData[4] * 256 + requetData[5];
var blenght = (byte)Math.Ceiling(registerLenght / 8f);
var tempData = new byte[registerLenght];
Buffer.BlockCopy(byteArray, address, tempData, 0, tempData.Length);
var rData = new byte[3 + registerLenght];
rData[0] = 1;
rData[1] = 1;
rData[2] = (byte)registerLenght;
for (int i = 0; i < blenght; i++)
{
rData[3 + i] = (byte)DataConvert.BinaryArrayToInt(string.Join("", tempData.Skip(i * 8).Take(8).Reverse()));
}
var responseData = CRC16.GetCRC16(rData);
serialPort.Write(responseData, 0, responseData.Length);
}
break;
//写入线圈
case 5:
{
var value = new byte[2];
Buffer.BlockCopy(requetData, requetData.Length - 4, value, 0, value.Length);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(stationNumberKey + "-Coil")) ?? new byte[65536];
if (value[0] == 0 && value[1] == 0)
{
byteArray[address] = 0;
}
else
{
byteArray[address] = 1;
}
dataPersist.Write(stationNumberKey + "-Coil", JsonConvert.SerializeObject(byteArray));
serialPort.Write(requetData, 0, requetData.Length);
}
break;
//读取
case 3:
{
var value = dataPersist.Read(stationNumberKey);
var byteArray = JsonConvert.DeserializeObject <byte[]>(value) ?? new byte[65536];
var dlength = requetData[4] * 256 + requetData[5];
var dataHead = new byte[] { 1, 3, (byte)(dlength * 2) };
var dataContent = new byte[dlength * 2];
Buffer.BlockCopy(byteArray, address * 2, dataContent, 0, dataContent.Length);
var tempData = dataHead.Concat(dataContent).ToArray();
var responseData = CRC16.GetCRC16(tempData);
serialPort.Write(responseData, 0, responseData.Length);
}
break;
//写入
case 16:
{
var value = new byte[requetData[6]];
Buffer.BlockCopy(requetData, 7, value, 0, value.Length);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(stationNumberKey)) ?? new byte[65536];
value.CopyTo(byteArray, address * 2);
dataPersist.Write(stationNumberKey, JsonConvert.SerializeObject(byteArray));
var tempData = new byte[6];
Buffer.BlockCopy(requetData, 0, tempData, 0, tempData.Length);
var responseData = CRC16.GetCRC16(tempData);
serialPort.Write(responseData, 0, responseData.Length);
}
break;
}
}
catch (Exception ex)
{ }
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[8];
//读取客户端发送过来的数据
int readLeng = newSocket.Receive(requetData1, 0, requetData1.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
newSocket.Shutdown(SocketShutdown.Both);
newSocket.Close();
return;
}
byte[] requetData2 = new byte[requetData1[5] - 2];
readLeng = newSocket.Receive(requetData2, 0, requetData2.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
newSocket.Shutdown(SocketShutdown.Both);
newSocket.Close();
return;
}
var requetData = requetData1.Concat(requetData2).ToArray();
byte[] responseData1 = new byte[8];
//复制请求报文中的报文头
Buffer.BlockCopy(requetData, 0, responseData1, 0, responseData1.Length);
DataPersist data = new DataPersist(redisConfig);
switch (requetData[7])
{
//读取线圈
case 1:
//TODO
break;
//写入线圈
case 5:
//TODO
break;
//读取
case 3:
{
var value = data.Read(requetData[9]);//TODO 数据存在 8、9
short.TryParse(value, out short resultValue);
var bytes = BitConverter.GetBytes(resultValue);
//当前位置到最后的长度
responseData1[5] = (byte)(3 + bytes.Length);
//TODO
byte[] responseData2 = new byte[3] { (byte)bytes.Length, bytes[1], bytes[0] };
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入
case 16:
{
//TODO
var value = requetData[requetData.Length - 2] * 256 + requetData[requetData.Length - 1];
data.Write(requetData[9], value.ToString());
var responseData = new byte[12];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 6;
newSocket.Send(responseData);
}
break;
}
}
catch (SocketException ex)
{
//todo
if (ex.SocketErrorCode != SocketError.ConnectionRefused ||
ex.SocketErrorCode != SocketError.ConnectionReset)
throw ex;
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] completeRequetData = null;
byte[] requetData1 = new byte[20];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
if (ByteArryThan(requetData1, BasicCommand))
{
var response = DataConvert.StringToByteArray("46 49 4E 53 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 01");
newSocket.Send(response);
continue;
}
byte[] requetData2 = new byte[34 - 20];
requetData2 = SocketRead(newSocket, requetData2.Length);
completeRequetData = requetData1.Concat(requetData2).ToArray();
var isBit = completeRequetData[28] == 0x02 ||
completeRequetData[28] == 0x30 ||
completeRequetData[28] == 0x31 ||
completeRequetData[28] == 0x32 ||
completeRequetData[28] == 0x33;
var addressLenght = isBit ? 1 : 2;
//1 读 2 写
var readWriteCode = requetData2[27 - 20];
//读写数据长度
var readWriteLength = requetData2[32 - 20] * 256 + requetData2[33 - 20];
if (readWriteCode == 0x02)//写
{
byte[] requetData3 = SocketRead(newSocket, readWriteLength * addressLenght);
completeRequetData = completeRequetData.Concat(requetData3).ToArray();
}
var dataKey = $"{completeRequetData[28]}";
var beginAddress = completeRequetData[30] + completeRequetData[29] * 256;
var bitAddress = completeRequetData[31];
switch (completeRequetData[27])
{
//读
case 0x01:
{
//把存储的数据转为字节数组
var dataValue = dataPersist.Read(dataKey);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataValue) ?? new byte[65536];
//数据的字节长度
var dataLenght = readWriteLength * addressLenght;
// 响应报文总长度
byte[] responseData = new byte[30 + dataLenght];
DataConvert.StringToByteArray("46 49 4E 53 00 00 00 1A 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00").CopyTo(responseData, 0);
//存储的是后面还有多少长度
responseData[4] = BitConverter.GetBytes(22 + dataLenght)[3];
responseData[5] = BitConverter.GetBytes(22 + dataLenght)[2];
responseData[6] = BitConverter.GetBytes(22 + dataLenght)[1];
responseData[7] = BitConverter.GetBytes(22 + dataLenght)[0];
if (isBit)
{
Buffer.BlockCopy(byteArray, beginAddress * 16 + bitAddress, responseData, 30, dataLenght);
}
else
{
Buffer.BlockCopy(byteArray, beginAddress * addressLenght, responseData, 30, dataLenght);
}
newSocket.Send(responseData);
}
break;
//写
case 0x02:
{
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(dataKey)) ?? new byte[65536];
//[32]后面存的是数据
var valueByte = new byte[completeRequetData.Length - 34];
Buffer.BlockCopy(completeRequetData, 34, valueByte, 0, valueByte.Length);
//var tempValue1 = BitConverter.ToSingle(valueByte.Reverse().ToArray().ByteFormatting(EndianFormat.CDAB), 0);
if (isBit)
{
valueByte.CopyTo(byteArray, beginAddress * 16 + bitAddress);
}
else
{
valueByte.CopyTo(byteArray, beginAddress * addressLenght);
}
dataPersist.Write(dataKey, JsonConvert.SerializeObject(byteArray));
newSocket.Send(DataConvert.StringToByteArray("46 49 4E 53 00 00 00 16 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00"));
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[4];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
byte[] requetData2 = new byte[requetData1[3] - 4];
requetData2 = SocketRead(newSocket, requetData2.Length);
var requetData = requetData1.Concat(requetData2).ToArray();
//如果是连接的时候发送的两次初始化指令 则直接跳过
if (requetData[3] == SiemensConstant.Command1_200Smart.Length || requetData[3] == SiemensConstant.Command2_200Smart.Length)
{
newSocket.Send(requetData);
continue;
}
switch (requetData[17])
{
//读
case 4:
{
var dbNumber = requetData[18];
//读取数据长度
var readLength = 0;
for (int i = 0; i < dbNumber; i++)
{
readLength += requetData[23 + i * 12] * 256 + requetData[24 + i * 12];
}
var dataContent = new byte[4 * dbNumber + readLength]; //可以从报文中获取Length？
var cursor = 0;
for (int i = 0; i < dbNumber; i++)
{
var address = requetData[28 + i * 12] * 256 * 256 + requetData[29 + i * 12] * 256 + requetData[30 + i * 12];
var tempReadLenght = requetData[23 + i * 12] * 256 + requetData[24 + i * 12];
var typeDB = requetData[27 + i * 12];
var stationNumberKey = $"s200-{typeDB}";
var value = dataPersist.Read(stationNumberKey);//TODO 数据存在 25、26
var byteArray = JsonConvert.DeserializeObject <byte[]>(value) ?? new byte[65536];
DataConvert.StringToByteArray("FF 09 00 04").CopyTo(dataContent, 0 + cursor);
dataContent[1 + cursor] = readLength == 1 ? (byte)0x03 : (byte)0x04; //04 byte(字节) 03bit（位）
dataContent[2 + cursor] = (byte)(readLength / 256);
dataContent[3 + cursor] = (byte)(readLength % 256);
Buffer.BlockCopy(byteArray, address / 8, dataContent, 4 + cursor, tempReadLenght);
cursor += 4 + tempReadLenght;
//dataContent[2] dataContent[3] 后半截数据数组的Length
//dataContent[4]-[7] 返回给客户端的数据
}
byte[] responseData1 = new byte[21 + dataContent.Length];
DataConvert.StringToByteArray("03 00 00 1A 02 F0 80 32 03 00 00 00 01 00 02 00 00 00 00 04 01").CopyTo(responseData1, 0);
//responseData1[8] = 0x03;//1 客户端发送命令 3 服务器回复命令
responseData1[2] = (byte)(responseData1.Length / 256);
responseData1[3] = (byte)(responseData1.Length % 256);
responseData1[15] = (byte)(requetData.Length / 256);
responseData1[16] = (byte)(requetData.Length % 256);
responseData1[20] = requetData[18];
dataContent.CopyTo(responseData1, 21);
//当读取的是字符串的时候[25]存储的后面的数据长度，参考SiemensClient的Write(string address, string value)方法。
//Buffer.BlockCopy(bytes, 0, responseData1, responseData1.Length - bytes.Length, bytes.Length);
newSocket.Send(responseData1);
}
break;
//写
case 5:
{
var address = requetData[28] * 256 * 256 + requetData[29] * 256 + requetData[30];
var typeDB = requetData[27];
var stationNumberKey = $"s200-{typeDB}";
var value = new byte[requetData.Length - 35];
Buffer.BlockCopy(requetData, 35, value, 0, value.Length);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(stationNumberKey)) ?? new byte[65536];
value.CopyTo(byteArray, address / 8);
//存储字节数据到内存
dataPersist.Write(stationNumberKey, JsonConvert.SerializeObject(byteArray));
byte[] responseData1 = new byte[22];
DataConvert.StringToByteArray("03 00 00 16 02 F0 80 32 03 00 00 00 01 00 02 00 01 00 00 05 01 FF").CopyTo(responseData1, 0);
newSocket.Send(responseData1);
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[21];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
byte[] requetData = null;
//[12] 0x14 写 0x04 读
if (requetData1[12] == 0x14)
{
var lenght = requetData1[20] * 2 * 256 + requetData1[19] * 2;
//如果是按Bit存储
if (requetData1[13] == 0x01)
{
lenght = 1;
}
byte[] requetData2 = new byte[lenght];
requetData2 = SocketRead(newSocket, requetData2.Length);
requetData = requetData1.Concat(requetData2).ToArray();
}
else
{
requetData = requetData1;
}
//地址
//var address = $"{requetData[18]}-{requetData[17] * 256 * 256 + requetData[16] * 256 + requetData[15]}";
var dataKey = $"{requetData[18]}";
var beginAddress = requetData[17] * 256 * 256 + requetData[16] * 256 + requetData[15];
//[13]0x01 位 0x00 字节
var isBit = requetData1[13] == 0x01;
var addressLenght = isBit ? 0.5 : 2;
switch (requetData[12])
{
//读
case 0x04:
{
//数据存储长度
var lenght = requetData[19] + requetData[20] * 256;
//var value = dataPersist.Read(address);
//把存储的数据转为字节数组
var dataValue = dataPersist.Read(dataKey);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataValue) ?? new byte[65536];
//数据的字节长度
var dataLenght = isBit ? (int)Math.Ceiling(lenght * addressLenght) : lenght * 2;
// 响应报文总长度
byte[] responseData = new byte[11 + dataLenght];
DataConvert.StringToByteArray("D0 00 00 FF FF 03 00 06 00 00 00").CopyTo(responseData, 0);
//responseData1[7][8]存储的是后面还有多少长度
responseData[7] = BitConverter.GetBytes(2 + dataLenght)[0];
responseData[8] = BitConverter.GetBytes(2 + dataLenght)[1];
if (isBit && lenght == 1)
{
var oldBitValue = byteArray[beginAddress / 2];
//一个字节存储两个点位数据
var bitOffset = beginAddress % 2;
if (bitOffset == 0)
{
responseData[11] = (oldBitValue & 0b00010000) != 0 ? (byte)0b00010000 : (byte)0b00000000;
}
else
{
responseData[11] = (oldBitValue & 0b00000001) != 0 ? (byte)0b00010000 : (byte)0b00000000;
}
}
else
{
Buffer.BlockCopy(byteArray, (int)Math.Floor(beginAddress * addressLenght), responseData, 11, dataLenght);
}
newSocket.Send(responseData);
}
break;
//写
case 0x14:
{
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(dataKey)) ?? new byte[65536];
//[21]后面存的是数据
var valueByte = new byte[requetData.Length - 21];
Buffer.BlockCopy(requetData, 21, valueByte, 0, valueByte.Length);
//存储字节数据到内存
//dataPersist.Write(address, JsonConvert.SerializeObject(valueByte));
if (isBit)
{
var oldBitValue = byteArray[beginAddress / 2];
var bitOffset = beginAddress % 2; //一个字节存储两个点位数据
if (valueByte[0] == 0x10) //true
{
if (bitOffset == 0)
{
oldBitValue = (byte)(oldBitValue | 0b00010000);
}
else
{
oldBitValue = (byte)(oldBitValue | 0b00000001);
}
}
else //false
{
if (bitOffset == 0)
{
oldBitValue = (byte)(oldBitValue & ~0b11111110); //修改成0b00000001或0b00000000
}
else
{
oldBitValue = (byte)(oldBitValue & ~0b11101111); //修改成0b00010000或0b00000000
}
}
new byte[] { oldBitValue }.CopyTo(byteArray, (int)Math.Floor(beginAddress * addressLenght));
}
else
{
valueByte.CopyTo(byteArray, (int)Math.Floor(beginAddress * addressLenght));
}
dataPersist.Write(dataKey, JsonConvert.SerializeObject(byteArray));
byte[] responseData1 = DataConvert.StringToByteArray("D0 00 00 FF FF 03 00 02 00 00 00");
newSocket.Send(responseData1);
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] completeRequetData = null;
byte[] requetData1 = new byte[28];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
if (ByteArryThan(requetData1, GetBasicCommand()))
{
//连接握手
var response = DataConvert.StringToByteArray("65 00 04 00 57 01 56 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00");
newSocket.Send(response);
continue;
}
byte[] requetData2 = new byte[40 - 28];
requetData2 = SocketRead(newSocket, requetData2.Length);
var requetLength = requetData2[requetData2.Length - 1] * 256 + requetData2[requetData2.Length - 2];
byte[] requetData3 = SocketRead(newSocket, requetLength);
completeRequetData = requetData1.Concat(requetData2).Concat(requetData3).ToArray();
var requst = string.Join(" ", completeRequetData.Select(t => t.ToString("X2")));
var address_ASCII_Length = completeRequetData[1 + 26 + 24] * 2 - 2;
var address_ASCII = new byte[address_ASCII_Length];
Buffer.BlockCopy(completeRequetData, 4 + 26 + 24, address_ASCII, 0, address_ASCII_Length);
var address = Encoding.ASCII.GetString(address_ASCII);
var CIP_Length = completeRequetData[24 + 24] + completeRequetData[25 + 24] * 256;
switch (completeRequetData[26 + 24])
{
//读
case 0x4C:
{
var value_byte = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(address)) ?? new byte[4];
var response = DataConvert.StringToByteArray("66 00 1A 00 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 02 00 00 00 00 00 B2 00 0A 00 CC 00 00 00 00 00 7B 00 00 00");
BitConverter.GetBytes((ushort)(value_byte.Length + 6)).CopyTo(response, 38);
value_byte.CopyTo(response, 46);
var response_str = string.Join(" ", response.Select(t => t.ToString("X2")));
newSocket.Send(response);
}
break;
//写
case 0x4D:
{
var value_Length = CIP_Length - address_ASCII_Length - 8;
var value_byte = new byte[value_Length];
Buffer.BlockCopy(completeRequetData, 8 + 26 + 24 + address_ASCII.Length, value_byte, 0, value_Length);
//var value = BitConverter.ToInt16(value_byte, 0);
dataPersist.Write(address, JsonConvert.SerializeObject(value_byte));
var response = DataConvert.StringToByteArray("66 00 16 00 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 02 00 00 00 00 00 B2 00 06 00 CD 00 00 00 00 00");
newSocket.Send(response);
}
break;
}
}
catch (Exception ex)
{
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[8];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
byte[] requetData2 = new byte[requetData1[5] - 2];
requetData2 = SocketRead(newSocket, requetData2.Length);
var requetData = requetData1.Concat(requetData2).ToArray();
byte[] responseData1 = new byte[8];
//复制请求报文中的报文头
Buffer.BlockCopy(requetData, 0, responseData1, 0, responseData1.Length);
var addressKey = $"{requetData[6]}-{requetData[8] * 256 + requetData[9]}";
switch (requetData[7])
{
//读取线圈
case 1:
{
var value = dataPersist.Read(addressKey + "-Coil"); // 数据存在 8、9
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (bytes == null)
{
bytes = new byte[2];
}
//当前位置到最后的长度
responseData1[5] = (byte)(2 + bytes.Length);
byte[] responseData2 = new byte[2] {
bytes[1], bytes[0]
};
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入线圈
case 5:
{
var value = new byte[2];
Buffer.BlockCopy(requetData, 10, value, 0, value.Length);
dataPersist.Write(addressKey + "-Coil", JsonConvert.SerializeObject(value));
var responseData = new byte[10];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 4; //后面的长度
newSocket.Send(responseData);
}
break;
//读取
case 3:
{
var value = dataPersist.Read(addressKey); // 数据存在 8、9
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (bytes == null)
{
var length = requetData[requetData.Length - 2] * 256 + requetData[requetData.Length - 1];
bytes = new byte[length * 2];
}
//当前位置到最后的长度
responseData1[5] = (byte)(3 + bytes.Length);
byte[] responseData2 = new byte[1 + bytes.Length];
responseData2[0] = (byte)bytes.Length;
bytes.CopyTo(responseData2, 1);
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入
case 16:
{
var value = new byte[requetData[12]];
Buffer.BlockCopy(requetData, 13, value, 0, value.Length);
dataPersist.Write(addressKey, JsonConvert.SerializeObject(value));
var responseData = new byte[12];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 6; //后面的长度
newSocket.Send(responseData);
}
break;
//读离散
case 2:
{
//只返回false
var bytes = new byte[2];
//当前位置到最后的长度
responseData1[5] = (byte)(2 + bytes.Length);
byte[] responseData2 = new byte[2] {
bytes[1], bytes[0]
};
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收数据回调用
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DataReceived(object sender, SerialDataReceivedEventArgs e)
{
try
{
byte[] requetData = new byte[serialPort.BytesToRead];
serialPort.Read(requetData, 0, requetData.Length);
var address = $"{requetData[5]}-{requetData[6]}-{requetData[7]}-{requetData[8]}";
byte[] tempData = new byte[requetData.Length - 3];
Buffer.BlockCopy(requetData, 1, tempData, 0, tempData.Length);
var requetAsciiData = DataConvert.AsciiArrayToByteArray(tempData);
var type = $"{requetData[3].ToString("X2")}{requetData[4].ToString("X2")}";
switch (type)
{
//读取线圈
case "3031":
{
var value = dataPersist.Read(address);
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
byte[] data = null;
//没有存储过的数据的，默认响应false
if (bytes == null)
{
data = DataConvert.StringToByteArray("01 01 01 00");
}
else
{
if (bytes[0].ToString("X2") != "3A" ||
bytes[bytes.Length - 2].ToString("X2") != "0D" ||
bytes[bytes.Length - 1].ToString("X2") != "0A")
{
throw new Exception("标记验证失败");
}
byte[] asciiData = new byte[bytes.Length - 3];
Buffer.BlockCopy(bytes, 1, asciiData, 0, asciiData.Length);
var byteDataArray = DataConvert.AsciiArrayToByteArray(asciiData);
//true
if (byteDataArray[4].ToString("X2") == "FF" && byteDataArray[5].ToString("X2") == "00")
{
data = DataConvert.StringToByteArray("01 01 01 01");
}
else //false
{
data = DataConvert.StringToByteArray("01 01 01 00");
}
}
var dataString = string.Join("", LRC.GetLRC(data).Select(t => t.ToString("X2")));
var databyte = Encoding.ASCII.GetBytes(dataString);
var responseData = new byte[databyte.Length + 3];
Buffer.BlockCopy(databyte, 0, responseData, 1, databyte.Length);
responseData[0] = 0x3A;
responseData[responseData.Length - 2] = 0x0D;
responseData[responseData.Length - 1] = 0x0A;
serialPort.Write(responseData, 0, responseData.Length);
}
break;
//写入线圈
case "3035":
{
dataPersist.Write(address, JsonConvert.SerializeObject(requetData));
serialPort.Write(requetData, 0, requetData.Length);
}
break;
//读取
case "3033":
{
var value = dataPersist.Read(address);
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
byte[] data = null;
if (bytes == null)
{
data = new byte[2 + 3];
data[2] = 2; //数据长度
}
else
{
if (bytes[0].ToString("X2") != "3A" ||
bytes[bytes.Length - 2].ToString("X2") != "0D" ||
bytes[bytes.Length - 1].ToString("X2") != "0A")
{
throw new Exception("标记验证失败");
}
byte[] asciiData = new byte[bytes.Length - 3];
Buffer.BlockCopy(bytes, 1, asciiData, 0, asciiData.Length);
var byteDataArray = DataConvert.AsciiArrayToByteArray(asciiData);
data = new byte[byteDataArray[6] + 3];
data[2] = byteDataArray[6]; //数据长度
Buffer.BlockCopy(byteDataArray, 7, data, 3, data.Length - 3);
}
data[0] = requetAsciiData[0]; //站号
data[1] = 0x03; //功能码
var dataString = string.Join("", LRC.GetLRC(data).Select(t => t.ToString("X2")));
var databyte = Encoding.ASCII.GetBytes(dataString);
var responseData = new byte[databyte.Length + 3];
Buffer.BlockCopy(databyte, 0, responseData, 1, databyte.Length);
responseData[0] = 0x3A;
responseData[responseData.Length - 2] = 0x0D;
responseData[responseData.Length - 1] = 0x0A;
serialPort.Write(responseData, 0, responseData.Length);
}
break;
//写入3130 对应十进制16 十六进制 10
case "3130":
{
dataPersist.Write(address, JsonConvert.SerializeObject(requetData));
serialPort.Write(requetData, 0, requetData.Length);
}
break;
}
}
catch (Exception ex)
{ }
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[21];
//读取客户端发送过来的数据
int readLeng = newSocket.Receive(requetData1, 0, requetData1.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
newSocket.Shutdown(SocketShutdown.Both);
newSocket.Close();
return;
}
byte[] requetData = null;
//[12] 0x14 写 0x04 读
if (requetData1[12] == 0x14)
{
var lenght = requetData1[20] * 2 * 256 + requetData1[19] * 2;
//如果是按Bit存储
if (requetData1[13] == 0x01)
{
lenght = 1;
}
byte[] requetData2 = new byte[lenght];
readLeng = newSocket.Receive(requetData2, 0, requetData2.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
if (newSocket?.Connected ?? false)
{
newSocket.Shutdown(SocketShutdown.Both);
}
newSocket?.Close();
return;
}
requetData = requetData1.Concat(requetData2).ToArray();
}
else
{
requetData = requetData1;
}
//地址
var address = $"{requetData[18].ToString()}-{requetData[17] * 256 * 256 + requetData[16] * 256 + requetData[15]}";
switch (requetData[12])
{
//读
case 0x04:
{
//[13]0x01 位 0x00 字节
var isBit = requetData1[13] == 0x01;
//数据存储长度
var lenght = requetData[19] + requetData[20] * 256;
var value = dataPersist.Read(address);
//把存储的数据转为字节数组
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (string.IsNullOrWhiteSpace(value))
{
bytes = BitConverter.GetBytes(0);
}
//数据的字节长度
var dataLenght = isBit ? 1 : lenght * 2;
// 响应报文总长度
byte[] responseData = new byte[11 + dataLenght];
DataConvert.StringToByteArray("D0 00 00 FF FF 03 00 06 00 00 00").CopyTo(responseData, 0);
//responseData1[7][8]存储的是后面还有多少长度
responseData[7] = BitConverter.GetBytes(2 + dataLenght)[0];
responseData[8] = BitConverter.GetBytes(2 + dataLenght)[1];
//正常数据应该是等于，则把数据全部附加过去
if (bytes.Length <= dataLenght)
{
bytes.CopyTo(responseData, 11);
}
else
{
Buffer.BlockCopy(bytes, 0, responseData, 11, dataLenght);
}
newSocket.Send(responseData);
}
break;
//写
case 0x14:
{
//[21]后面存的是数据
var valueByte = new byte[requetData.Length - 21];
Buffer.BlockCopy(requetData, 21, valueByte, 0, valueByte.Length);
//存储字节数据到内存
dataPersist.Write(address, JsonConvert.SerializeObject(valueByte));
byte[] responseData1 = DataConvert.StringToByteArray("D0 00 00 FF FF 03 00 02 00 00 00");
newSocket.Send(responseData1);
}
break;
}
}
catch (SocketException ex)
{
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[8];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
byte[] requetData2 = new byte[requetData1[5] - 2];
requetData2 = SocketRead(newSocket, requetData2.Length);
var requetData = requetData1.Concat(requetData2).ToArray();
byte[] responseData1 = new byte[8];
//复制请求报文中的报文头
Buffer.BlockCopy(requetData, 0, responseData1, 0, responseData1.Length);
var addressKey = $"{requetData[6]}-{requetData[8] * 256 + requetData[9]}"; //站号-寄存器地址
var stationNumberKey = $"{requetData[6]}-key"; //站号
var address = requetData[8] * 256 + requetData[9]; //寄存器地址
var registerLenght = requetData[10] * 256 + requetData[11]; //寄存器的长度
switch (requetData[7])
{
//读取线圈
case 1:
{
var value = dataPersist.Read(stationNumberKey + "-Coil"); // 数据存在 8、9
var byteArray = JsonConvert.DeserializeObject <byte[]>(value) ?? new byte[65536];
var blenght = (byte)Math.Ceiling(registerLenght / 8f);
//当前位置到最后的长度
responseData1[5] = (byte)(3 + blenght);
byte[] responseData2 = new byte[1 + blenght];
var tempData = new byte[registerLenght];
Buffer.BlockCopy(byteArray, address, tempData, 0, tempData.Length);
responseData2[0] = blenght; //显示数据所占长度
for (int i = 0; i < blenght; i++)
{
responseData2[1 + i] = (byte)DataConvert.BinaryArrayToInt(string.Join("", tempData.Skip(i * 8).Take(8).Reverse()));
}
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入线圈
case 5:
{
var value = new byte[2];
Buffer.BlockCopy(requetData, 10, value, 0, value.Length);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(stationNumberKey + "-Coil")) ?? new byte[65536];
if (value[0] == 0 && value[1] == 0)
{
byteArray[address] = 0;
}
else
{
byteArray[address] = 1;
}
dataPersist.Write(stationNumberKey + "-Coil", JsonConvert.SerializeObject(byteArray));
var responseData = new byte[10];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 4; //后面的长度
newSocket.Send(responseData);
}
break;
//读取
case 3:
{
var value = dataPersist.Read(stationNumberKey); // 数据存在 8、9
var byteArray = JsonConvert.DeserializeObject <byte[]>(value) ?? new byte[65536];
//当前位置到最后的长度
responseData1[4] = (byte)((3 + registerLenght * 2) / 256);
responseData1[5] = (byte)((3 + registerLenght * 2) % 256);
byte[] responseData2 = new byte[1 + registerLenght * 2];
responseData2[0] = (byte)(registerLenght * 2);
Buffer.BlockCopy(byteArray, address * 2, responseData2, 1, registerLenght * 2);
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入
case 16:
{
var value = new byte[requetData[12]];
Buffer.BlockCopy(requetData, 13, value, 0, value.Length);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(stationNumberKey)) ?? new byte[65536];
value.CopyTo(byteArray, address * 2);
dataPersist.Write(stationNumberKey, JsonConvert.SerializeObject(byteArray));
var responseData = new byte[12];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 6; //后面的长度
newSocket.Send(responseData);
}
break;
//读离散
case 2:
{
//只返回false
var bytes = new byte[2];
//当前位置到最后的长度
responseData1[5] = (byte)(2 + bytes.Length);
byte[] responseData2 = new byte[2] {
bytes[1], bytes[0]
};
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[4];
//读取客户端发送过来的数据
int readLeng = newSocket.Receive(requetData1, 0, requetData1.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
newSocket.Shutdown(SocketShutdown.Both);
newSocket.Close();
return;
}
byte[] requetData2 = new byte[requetData1[3] - 4];
readLeng = newSocket.Receive(requetData2, 0, requetData2.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
if (newSocket?.Connected ?? false)
{
newSocket.Shutdown(SocketShutdown.Both);
}
newSocket?.Close();
return;
}
var requetData = requetData1.Concat(requetData2).ToArray();
//如果是连接的时候发送的两次初始化指令 则直接跳过
if (requetData[3] == SiemensConstant.Command1_200Smart.Length || requetData[3] == SiemensConstant.Command2_200Smart.Length)
{
newSocket.Send(requetData);
continue;
}
var address = requetData[28] * 256 * 256 + requetData[29] * 256 + requetData[30];
switch (requetData[17])
{
//读
case 4:
{
var value = dataPersist.Read(address); //TODO 数据存在 25、26
//把存储的数据转为字节数组
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (string.IsNullOrWhiteSpace(value))
{
bytes = BitConverter.GetBytes(0);
}
var dataContent = new byte[4 + bytes.Length]; //可以从报文中获取Length？
DataConvert.StringToByteArray("FF 09 00 04").CopyTo(dataContent, 0);
dataContent[1] = bytes.Length == 1 ? (byte)0x03 : (byte)0x04; //04 byte(字节) 03bit（位）
dataContent[2] = (byte)(bytes.Length / 256);
dataContent[3] = (byte)(bytes.Length % 256);
//dataContent[0] 固定
//dataContent[2] dataContent[3] 后半截数据数组的Length
//dataContent[4]-[7] 返回给客户端的数据
byte[] responseData1 = new byte[21 + dataContent.Length];
DataConvert.StringToByteArray("03 00 00 1A 02 F0 80 32 03 00 00 00 01 00 02 00 00 00 00 04 01").CopyTo(responseData1, 0);
//responseData1[0] = 0x03;
//responseData1[1] = 0x00; //固定协议头
//responseData1[8] = 0x03;//1 客户端发送命令 3 服务器回复命令
responseData1[2] = (byte)(responseData1.Length / 256);
responseData1[3] = (byte)(responseData1.Length % 256);
responseData1[15] = (byte)(requetData.Length / 256);
responseData1[16] = (byte)(requetData.Length % 256);
responseData1[20] = requetData[18];
dataContent.CopyTo(responseData1, 21);
Buffer.BlockCopy(bytes, 0, responseData1, responseData1.Length - bytes.Length, bytes.Length);
newSocket.Send(responseData1);
}
break;
//写
case 5:
{
var valueByte = new byte[requetData.Length - 35];
Buffer.BlockCopy(requetData, 35, valueByte, 0, valueByte.Length);
//存储字节数据到内存
dataPersist.Write(address, JsonConvert.SerializeObject(valueByte));
byte[] responseData1 = new byte[22];
DataConvert.StringToByteArray("03 00 00 16 02 F0 80 32 03 00 00 00 01 00 02 00 01 00 00 05 01 FF").CopyTo(responseData1, 0);
//responseData1[15] = (byte)(responseData1.Length / 256);
//responseData1[16] = (byte)(responseData1.Length % 256);
newSocket.Send(responseData1);
}
break;
}
}
catch (SocketException ex)
{
//todo
//if (ex.SocketErrorCode != SocketError.ConnectionRefused &&
// ex.SocketErrorCode != SocketError.ConnectionReset)
// throw ex;
}
}
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[4];
//读取客户端发送过来的数据
requetData1 = SocketRead(newSocket, requetData1.Length);
byte[] requetData2 = new byte[requetData1[2] * 256 + requetData1[3] - 4];
requetData2 = SocketRead(newSocket, requetData2.Length);
var requetData = requetData1.Concat(requetData2).ToArray();
//如果是连接的时候发送的两次初始化指令 则直接跳过
if (requetData[3] == SiemensConstant.Command1_200Smart.Length || requetData[3] == SiemensConstant.Command2_200Smart.Length)
{
newSocket.Send(requetData);
continue;
}
switch (requetData[17])
{
//读
case 4:
{
//数据块个数
var dbNumber = requetData[18];
//读取数据总长度
var readLength = 0;
for (int i = 0; i < dbNumber; i++)
{
//访问数据的个数，以byte为单位
var byteLength = requetData[23 + i * 12] * 256 + requetData[24 + i * 12];
if (byteLength == 1 && i < dbNumber - 1) //非最后一个bit/byte，需要补全。
{
byteLength += 1;
}
readLength += byteLength;
}
var dataContent = new byte[4 * dbNumber + readLength]; //数据报文总长度
var cursor = 0;
for (int i = 0; i < dbNumber; i++)
{
//DB块的偏移量
var beginAddress = requetData[28 + i * 12] * 256 * 256 + requetData[29 + i * 12] * 256 + requetData[30 + i * 12];
//访问数据的个数
var byteLength = requetData[23 + i * 12] * 256 + requetData[24 + i * 12];
if (byteLength == 1 && i < dbNumber - 1) //非最后一个bit/byte，需要补全。
{
byteLength += 1;
}
//是否是bit类型
var isBit = requetData[22 + i * 12] == 0x01;
//访问数据块的类型（V、I、DB...）
var dbType = requetData[27 + i * 12];
var dataKey = $"s200-{dbType}";
var dataValue = dataPersist.Read(dataKey);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataValue) ?? new byte[65536];
//DataConvert.StringToByteArray("FF 09 00 04").CopyTo(dataContent, cursor);
dataContent[0 + cursor] = 0xFF;
//dataContent[1 + cursor] = readLength == 1 ? (byte)0x03 : (byte)0x04;//04 byte(字节) 03bit（位）
dataContent[1 + cursor] = isBit ? (byte)0x03 : (byte)0x04; //04 byte(字节) 03bit（位）
dataContent[2 + cursor] = (byte)(byteLength / 256); //后半截数据数的Length
dataContent[3 + cursor] = (byte)(byteLength % 256); //后半截数据数的Length
if (isBit) //按bit
{
var bitOffset = beginAddress % 8;
byte bitOffsetValue = (byte)Math.Pow(2, bitOffset);
var oldBitValue = byteArray[beginAddress / 8];
//转成bit的形式所需的返回值
var bitValue = (oldBitValue & bitOffsetValue) != 0 ? 0x01 : 0x00;
//[4 + cursor]返回给客户端的数据
new byte[] { (byte)bitValue }.CopyTo(dataContent, 4 + cursor);
}
else
{
//[4 + cursor]返回给客户端的数据
Buffer.BlockCopy(byteArray, beginAddress / 8, dataContent, 4 + cursor, byteLength);
}
cursor += 4 + byteLength;
}
byte[] responseData = new byte[21 + dataContent.Length];
DataConvert.StringToByteArray("03 00 00 1A 02 F0 80 32 03 00 00 00 01 00 02 00 00 00 00 04 01").CopyTo(responseData, 0);
responseData[8] = 0x03; //1 客户端发送命令 3 服务器回复命令
responseData[2] = (byte)(responseData.Length / 256); //返回数据长度
responseData[3] = (byte)(responseData.Length % 256);
responseData[15] = (byte)(requetData.Length / 256); //读取数据长度
responseData[16] = (byte)(requetData.Length % 256);
responseData[20] = requetData[18]; //读取数据块个数
dataContent.CopyTo(responseData, 21);
newSocket.Send(responseData);
}
break;
//写
case 5:
{
var writesLength = requetData[18]; //写如数据的个数 Item count
int cursor = 0;
for (int i = 0; i < writesLength; i++)
{
//DB块的偏移量（存储数据的地址）
var beginAddress = requetData[28 + i * 12] * 256 * 256 + requetData[29 + i * 12] * 256 + requetData[30 + i * 12];
//访问数据块的类型（V、I、DB...）
var dbType = requetData[27 + i * 12];
var dataKey = $"s200-{dbType}";
//Data之前的下标
var dataBeforeIndex = 18 + writesLength * 12;
//[2 + index]是否是bit类型
var isBit = requetData[dataBeforeIndex + 4 * (i + 1) - 2 + cursor] == 0x03;
var coefficient = isBit ? 1 : 8;
//初始化要写入的字节数组长度
var writeValue = new byte[requetData[dataBeforeIndex + 4 * (i + 1) + cursor] / coefficient];
//开始写入的地址（报文中的数据的位置）
var requetBeginLocation = dataBeforeIndex + 4 * (i + 1) + cursor + 1;
//非最后一个bit，需要补全。
if (writeValue.Length == 1 && i < writesLength - 1)
{
cursor++;
}
cursor += writeValue.Length;
//数据赋值到writeValue中
Buffer.BlockCopy(requetData, requetBeginLocation, writeValue, 0, writeValue.Length);
var byteArray = JsonConvert.DeserializeObject <byte[]>(dataPersist.Read(dataKey)) ?? new byte[65536];
if (isBit)
{
var oldBitValue = byteArray[beginAddress / 8];
var bitOffset = beginAddress % 8;
byte bitOffsetValue = (byte)Math.Pow(2, bitOffset);
if (writeValue[0] == 0x01) //true
{
oldBitValue = (byte)(oldBitValue | bitOffsetValue); //组合bitOffsetValue
}
else //false
{
oldBitValue = (byte)(oldBitValue & ~bitOffsetValue); //去掉bitOffsetValue
}
new byte[] { oldBitValue }.CopyTo(byteArray, beginAddress / 8);
}
else
{
writeValue.CopyTo(byteArray, beginAddress / 8);
}
//存储字节数据到内存
dataPersist.Write(dataKey, JsonConvert.SerializeObject(byteArray));
}
byte[] responseData1 = new byte[22];
DataConvert.StringToByteArray("03 00 00 16 02 F0 80 32 03 00 00 00 01 00 02 00 01 00 00 05 01 FF").CopyTo(responseData1, 0);
newSocket.Send(responseData1);
}
break;
}
}
catch (Exception ex)
{
//if (newSocket?.Connected ?? false) newSocket?.Shutdown(SocketShutdown.Both);
//newSocket?.Close();
//throw ex;
}
}
}
/// <summary>
/// 接收数据回调用
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DataReceived(object sender, SerialDataReceivedEventArgs e)
{
try
{
byte[] requetData = new byte[serialPort.BytesToRead];
serialPort.Read(requetData, 0, requetData.Length);
var address = requetData[2] * 256 + requetData[3];
switch (requetData[1])
{
//读取线圈
case 1:
{
var value = dataPersist.Read(address);
var bytes = JsonConvert.DeserializeObject <byte[]>(value).Reverse().ToArray();
var tempData = new byte[4];
tempData[0] = 1;
tempData[1] = 1;
Buffer.BlockCopy(bytes, 0, tempData, 2, 2);
var responseData = CRC16.GetCRC16(tempData);
serialPort.Write(responseData, 0, responseData.Length);
}
break;
//写入线圈
case 5:
{
var value = new byte[2];
Buffer.BlockCopy(requetData, requetData.Length - 4, value, 0, value.Length);
dataPersist.Write(address, JsonConvert.SerializeObject(value));
serialPort.Write(requetData, 0, requetData.Length);
}
break;
//读取
case 3:
{
var value = dataPersist.Read(address);
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (bytes == null)
{
var length = requetData[4] * 256 + requetData[5];
bytes = new byte[length * 2];
}
var dataHead = new byte[] { 1, 3, (byte)bytes.Length };
var tempData = dataHead.Concat(bytes).ToArray();
var responseData = CRC16.GetCRC16(tempData);
serialPort.Write(responseData, 0, responseData.Length);
}
break;
//写入
case 16:
{
var value = new byte[requetData[6]];
Buffer.BlockCopy(requetData, 7, value, 0, value.Length);
dataPersist.Write(address, JsonConvert.SerializeObject(value));
var tempData = new byte[6];
Buffer.BlockCopy(requetData, 0, tempData, 0, tempData.Length);
var responseData = CRC16.GetCRC16(tempData);
serialPort.Write(responseData, 0, responseData.Length);
}
break;
}
}
catch (Exception ex)
{ }
}
/// <summary>
/// 接收客户端发送的消息
/// </summary>
/// <param name="newSocket"></param>
void Receive(Socket newSocket)
{
while (newSocket.Connected)
{
try
{
byte[] requetData1 = new byte[8];
//读取客户端发送过来的数据
int readLeng = newSocket.Receive(requetData1, 0, requetData1.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
if (newSocket.Connected)
{
newSocket.Shutdown(SocketShutdown.Both);
}
newSocket.Close();
return;
}
byte[] requetData2 = new byte[requetData1[5] - 2];
readLeng = newSocket.Receive(requetData2, 0, requetData2.Length, SocketFlags.None);
if (readLeng == 0)//客户端断开连接
{
if (newSocket.Connected)
{
newSocket.Shutdown(SocketShutdown.Both);
}
newSocket.Close();
return;
}
var requetData = requetData1.Concat(requetData2).ToArray();
byte[] responseData1 = new byte[8];
//复制请求报文中的报文头
Buffer.BlockCopy(requetData, 0, responseData1, 0, responseData1.Length);
var address = requetData[8] * 256 + requetData[9];
switch (requetData[7])
{
//读取线圈
case 1:
{
var value = dataPersist.Read(address); // 数据存在 8、9
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
//当前位置到最后的长度
responseData1[5] = (byte)(2 + bytes.Length);
//TODO
byte[] responseData2 = new byte[2] {
bytes[1], bytes[0]
};
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入线圈
case 5:
{
var value = new byte[2];
Buffer.BlockCopy(requetData, 10, value, 0, value.Length);
dataPersist.Write(address, JsonConvert.SerializeObject(value));
var responseData = new byte[10];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 4; //后面的长度
newSocket.Send(responseData);
}
break;
//读取
case 3:
{
var value = dataPersist.Read(address); // 数据存在 8、9
var bytes = JsonConvert.DeserializeObject <byte[]>(value);
if (bytes == null)
{
var length = requetData[requetData.Length - 2] * 256 + requetData[requetData.Length - 1];
bytes = new byte[length * 2];
}
//当前位置到最后的长度
responseData1[5] = (byte)(3 + bytes.Length);
byte[] responseData2 = new byte[1 + bytes.Length];
responseData2[0] = (byte)bytes.Length;
bytes.CopyTo(responseData2, 1);
var responseData = responseData1.Concat(responseData2).ToArray();
newSocket.Send(responseData);
}
break;
//写入
case 16:
{
var value = new byte[requetData[12]];
Buffer.BlockCopy(requetData, 13, value, 0, value.Length);
dataPersist.Write(address, JsonConvert.SerializeObject(value));
var responseData = new byte[12];
Buffer.BlockCopy(requetData, 0, responseData, 0, responseData.Length);
responseData[5] = 6; //后面的长度
newSocket.Send(responseData);
}
break;
}
}
catch (SocketException ex)
{
if (newSocket?.Connected ?? false)
{
newSocket?.Shutdown(SocketShutdown.Both);
}
newSocket?.Close();
}
catch (Exception ex)
{
if (newSocket?.Connected ?? false)
{
newSocket?.Shutdown(SocketShutdown.Both);
}
newSocket?.Close();
}
}
}
