/// <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="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[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="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();
}
}
}
