private int[] pl = new int[3];
private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
int bytes = 0;
bytes = serialPort1.BytesToRead;//读取串口中的数据
if (bytes > 0)
{
Flag = 1;//标志位
byte[] buffer = new byte[bytes];//转换成数组
serialPort1.Read(buffer, 0, bytes);//读取缓冲数据
for (int b = 0; b < bytes; b++)
{
pl[b] = buffer[b];
}
}
在另外一个函数里处理
pulse=pl[0]*100+pl[1]+pl[2];
本来显示出的数值应该是几十的数，但是显示20多个数会出现一次错误，比如400多
28 个解决方案
#1
serialPort1_DataReceived
不能保证你收到3个字节才触发执行
有可能只收到了1个字节,它就执行了
于是你数组里其中1个字节是新的,而另外2个是上次收到的
你先把收到的数据放List<byte>里,判断它足够3个了,再处理,处理完删除前3个,继续往里放新的数据
不能保证你收到3个字节才触发执行
有可能只收到了1个字节,它就执行了
于是你数组里其中1个字节是新的,而另外2个是上次收到的
你先把收到的数据放List<byte>里,判断它足够3个了,再处理,处理完删除前3个,继续往里放新的数据
#2
此外,你协议里应该有头有尾,不要就发3个字节的数据
那样你没法区分什么时候是开始,什么时候算结束
比如人家给你发的是1,2,3,1,2,3,本来是连续两组数据,数值是一样的
结果可能你收到的时候是这样收的:2,3,1
那样你没法区分什么时候是开始,什么时候算结束
比如人家给你发的是1,2,3,1,2,3,本来是连续两组数据,数值是一样的
结果可能你收到的时候是这样收的:2,3,1
#3
搜一搜modbus rtu
参考人家的协议是怎么定义的
你也可以自定义一种协议
但是起码要能区分从哪里算开始,哪些是数据,到哪里是结尾了
参考人家的协议是怎么定义的
你也可以自定义一种协议
但是起码要能区分从哪里算开始,哪些是数据,到哪里是结尾了
#4
我这个程序是一直运行接收单片机传来的数组，能不能给个接收的例子，我刚学c#，不太懂你说的
#5
读写串口的例子
你可以参考其中API,同步读串口的例子,这样可以有效的控制2次间隔发送的数据粘包的问题
但是串口不同于TCP协议,它不是安全的传输方式,受干扰很容易造成数据错乱
你的协议里没有校验,那么就很可能造成数据波动很大
不行程序判断一下跟上次的数据差异太大就丢弃好了
你可以参考其中API,同步读串口的例子,这样可以有效的控制2次间隔发送的数据粘包的问题
但是串口不同于TCP协议,它不是安全的传输方式,受干扰很容易造成数据错乱
你的协议里没有校验,那么就很可能造成数据波动很大
不行程序判断一下跟上次的数据差异太大就丢弃好了
#6
而且串口数据没有"包"的概念,它是一个字节一个字节发送,一个字节一个字节接收的
你得自己判断什么时候算一组数据,什么时候它是下一组数据了
你得自己判断什么时候算一组数据,什么时候它是下一组数据了
#7
我用的是serialport
#8
一样的.
serialport其实也是封装的API.
只不过封装完了之后,有便利,也有BUG.所以保留API的方式有时候能派上用处
我是让你参考写法,不是让你copy代码
serialport其实也是封装的API.
只不过封装完了之后,有便利,也有BUG.所以保留API的方式有时候能派上用处
我是让你参考写法,不是让你copy代码
#9
这个真没看懂....我刚学
#10
你的计算公式需要单片机发来的三个字节的数吧，但实际上有时候单片机发过来一个字节的时候serialPort1_DataReceived就会执行，这样你那个pulse=pl[0]*100+pl[1]+pl[2];访问pl数组不就越界了吗？
#11
不是越界吧，是用了上次的数据吧
#12
看不懂就没啥办法了
恶补基础呗
给了代码还看不懂,真心没法再帮了
恶补基础呗
给了代码还看不懂,真心没法再帮了
#13
有没有再简单一些的代码
#14
这已经够简单的了,收到什么就显示什么
还没做复杂协议判断头尾,判断数据是否合法,判断校验是否正确之类的呢
还没做复杂协议判断头尾,判断数据是否合法,判断校验是否正确之类的呢
#15
有越界情况，也有你说的情况，看来你很明白了。既然明白了问题根源，解决方案应该也有了。
#16
没有啊，我还没找到解决办法呢
#17
//从RS232读取数据
//ComPort: 0:COM1 1:COM2
//Kind: 0:从设备接收字符串 1:从产品接收多字节数据,并转换为字符串输出.
public string ReadRS232(int ComPort, int Kind)
{
string TempStr = "";
try
{
if (Kind == 0)
{
switch (ComPort)
{
case 0:
if (!com.serialPort1.IsOpen) com.serialPort1.Open();
if (!(com.serialPort1.BaudRate == 9600)) com.serialPort1.BaudRate = 9600;
if (!(com.serialPort1.DataBits == 8)) com.serialPort1.DataBits = 8;
if (!(com.serialPort1.StopBits == System.IO.Ports.StopBits.One)) com.serialPort1.StopBits = System.IO.Ports.StopBits.One;
if (!(com.serialPort1.Parity == System.IO.Ports.Parity.None)) com.serialPort1.Parity = System.IO.Ports.Parity.None;
if (com.serialPort1.BytesToRead > 0)
TempStr = com.serialPort1.ReadExisting();
com.serialPort1.DiscardInBuffer();
com.serialPort1.DiscardOutBuffer();
break;
case 1:
以前用的，读取返回字符串。
#18
不明白你的需求，是每取三个字节处理一次还是要做更多处理。
如果是三个字节处理一次，可试试如下代码：
如果串口是连续发送数据，那么可能出现缓冲池每次读取到超过三个字节数据的问题，可通过嵌套来进行重复计算。
如果是三个字节处理一次，可试试如下代码：
如果串口是连续发送数据，那么可能出现缓冲池每次读取到超过三个字节数据的问题，可通过嵌套来进行重复计算。
//建立一个数据缓冲池，每次串口收到数据，自动添加到缓冲池尾，数据从缓冲池头读取，读取几位删除几位
private StringBuilder strLst;
private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
int n = sPort.BytesToRead;
byte[] buf = new byte[n];
serialPort1.Read(buf, 0, n);
this.Invoke((EventHandler)(delegate
{
foreach (byte b in buf)
{
strLst.Append(b.ToString("X2") + " ");
}
//如果缓冲池获取的数据小于三个字节，则继续等待，直到获取到三个以上字节
if (strLst.Count < 3)
{
return;
}
else
{
MyFunction(strLst);
}
}));
}
private void MyFunction(stringBuilder pl)
{
pulse=int.parse(pl[0].Text)*100+int.parse(pl[1].Text)+int.parse(pl[2].Text);
//缓冲池删除三个字节，判断剩余数量是否有三个字节，有则重新计算，知道缓冲池内数据长度小于三个字节
pl.RemoveRange(0, 3)
if(pl.Count > 3)
{
MyFunction(pl)
}
}
#19
两种方案
1.设计数据传输协议，比如你需要的数据是1、2、3，但单片机应该发送这样一组数据，b,1,2,3,e，b表示begin，e表示结束，这样，serialPort1_DataReceived中就可以根据接收到的数据做相应的处理，保证完全收到一组正常数据后在拿1,2,3去进行计算。当然，协议设计部分只是简单举一个例子，协议具体格式你自己定；
2.我想你不会选择方案1，那么我再说一个更简单的。定义一个类成员变量，list<int> datalist = new .....，serialPort1_DataReceived中收到数据后，把数据追加到datalist中，再判断datalist的长度，如果>=3，那么拿出下标0-2的数据进行计算，计算后将0-2的数据删除。
#20
说那么多，其实就是TCP粘包了！
#21
怎么解决啊？
#22
那删除完呢，后边的数应该放到0-2中吧
#23
工业串口和网络软件通讯平台（下载）
http://www.bmpj.net/index.php?m=product&f=view&id=1
看看这个，你需要不！！！
http://www.bmpj.net/index.php?m=product&f=view&id=1
看看这个，你需要不！！！
#24
你可以试验一下
#25
LS那几位给方案本质上就是组包和拆包的 其实就是TCP粘包导致的
TCP解决方式有很多种，
这个文章是我写的
你可以参考下，不一定按照我的方法来，你要是懂了TCP粘包的原理，自己都能写了
http://www.cnblogs.com/wangjun8868/p/4380187.html
#26
按你上面的代码，不能光判断接收数据大于0就处理，如果一次只传来一个数据，这样你的代码仍然会处理，但是在后面的代码中，可能会越界。
对于你说的之前的数据参与到操作中来，你每次对数据处理完了，清空一下数据，就不会出现重复数据操作的情况了。
针对你上面的代码，简单理解是只针对三个数据的接收处理，简单点你把那个限制规定为3（在没有头尾，长度，校验等的规定下），不到3个数据不处理，试试。不过这种情况，是上传数据端，不会连续发送数据。
如果大于3个数据的情况，可以像上面同志们说的，先存起来，再处理。
对于你说的之前的数据参与到操作中来，你每次对数据处理完了，清空一下数据，就不会出现重复数据操作的情况了。
针对你上面的代码，简单理解是只针对三个数据的接收处理，简单点你把那个限制规定为3（在没有头尾，长度，校验等的规定下），不到3个数据不处理，试试。不过这种情况，是上传数据端，不会连续发送数据。
如果大于3个数据的情况，可以像上面同志们说的，先存起来，再处理。
#27
你是用 bytes = serialPort1.BytesToRead;//读取串口中的数据 的吗？
#28
Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。
int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
received_count += n;//增加接收计数
comm.Read(buf, 0, n);//读取缓冲数据
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//<协议解析>
bool data_1_catched = false;//缓存记录数据是否捕获到
//1.缓存数据
buffer.AddRange(buf);
//2.完整性判断
while (buffer.Count >= 12)//至少要包含头（2字节）+长度（1字节）+校验（1字节）
{
//请不要担心使用>=，因为>=已经和>,<,=一样，是独立操作符，并不是解析成>和=2个符号
//2.1 查找数据头
if (buffer[0] == 0x02 && buffer[11] == 0x03)
{
//2.2 探测缓存数据是否有一条数据的字节，如果不够，就不用费劲的做其他验证了
//前面已经限定了剩余长度>=12，那我们这里一定能访问到buffer[2]这个长度
//int len = buffer[2];//数据长度
//数据完整判断第一步，长度是否足够
//len是数据段长度,4个字节是while行注释的3部分长度
if (buffer.Count < 12) break;//数据不够的时候什么都不做
//这里确保数据长度足够，数据头标志找到，我们开始计算校验
//2.3 校验数据，确认数据正确
//异或校验，逐个字节异或得到校验码
byte checksum = 0;
checksum =(byte) (((buffer[9]&0xf0)>>4)^(buffer[10]&0x0f));
if (checksum != 0x1B) //如果数据校验失败，丢弃这一包数据
{
buffer.RemoveRange(0, 12);//从缓存中删除错误数据
continue;//继续下一次循环
}
//至此，已经被找到了一条完整数据。我们将数据直接分析，或是缓存起来一起分析
//我们这里采用的办法是缓存一次，好处就是如果你某种原因，数据堆积在缓存buffer中
//已经很多了，那你需要循环的找到最后一组，只分析最新数据，过往数据你已经处理不及时
//了，就不要浪费更多时间了，这也是考虑到系统负载能够降低。
buffer.CopyTo(0, binary_data_1, 0, 12);//复制一条完整数据到具体的数据缓存
data_1_catched = true;
buffer.RemoveRange(0, 12);//正确分析一条数据，从缓存中移除数据。
}
else
{
//这里是很重要的，如果数据开始不是头，则删除数据
buffer.RemoveAt(0);
}
}
//分析数据
if (data_1_catched)
{
//我们的数据都是定好格式的，所以当我们找到分析出的数据1，就知道固定位置一定是这些数据，我们只要显示就可以了
string data = binary_data_1[3].ToString("X2") + " " + binary_data_1[4].ToString("X2") + " " +
binary_data_1[5].ToString("X2") + " " + binary_data_1[6].ToString("X2") + " " +
binary_data_1[7].ToString("X2");
//更新界面
this.Invoke((EventHandler)(delegate { txData.Text = data; }));
}
//如果需要别的协议，只要扩展这个data_n_catched就可以了。往往我们协议多的情况下，还会包含数据编号，给来的数据进行
//编号，协议优化后就是： 头+编号+长度+数据+校验
//</协议解析>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
builder.Clear();//清除字符串构造器的内容
//因为要访问ui资源，所以需要使用invoke方式同步ui。
this.Invoke((EventHandler)(delegate
{
//判断是否是显示为16禁止
if (checkBoxHexView.Checked)
{
//依次的拼接出16进制字符串
foreach (byte b in buf)
{
builder.Append(b.ToString("X2") + " ");
}
}
else
{
//直接按ASCII规则转换成字符串
builder.Append(Encoding.ASCII.GetString(buf));
}
//追加的形式添加到文本框末端，并滚动到最后。
this.txGet.AppendText(builder.ToString());
//修改接收计数
labelGetCount.Text = "Get:" + received_count.ToString();
}));
}
finally
{
Listening = false;//我用完了，ui可以关闭串口了。
}
int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
received_count += n;//增加接收计数
comm.Read(buf, 0, n);//读取缓冲数据
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//<协议解析>
bool data_1_catched = false;//缓存记录数据是否捕获到
//1.缓存数据
buffer.AddRange(buf);
//2.完整性判断
while (buffer.Count >= 12)//至少要包含头（2字节）+长度（1字节）+校验（1字节）
{
//请不要担心使用>=，因为>=已经和>,<,=一样，是独立操作符，并不是解析成>和=2个符号
//2.1 查找数据头
if (buffer[0] == 0x02 && buffer[11] == 0x03)
{
//2.2 探测缓存数据是否有一条数据的字节，如果不够，就不用费劲的做其他验证了
//前面已经限定了剩余长度>=12，那我们这里一定能访问到buffer[2]这个长度
//int len = buffer[2];//数据长度
//数据完整判断第一步，长度是否足够
//len是数据段长度,4个字节是while行注释的3部分长度
if (buffer.Count < 12) break;//数据不够的时候什么都不做
//这里确保数据长度足够，数据头标志找到，我们开始计算校验
//2.3 校验数据，确认数据正确
//异或校验，逐个字节异或得到校验码
byte checksum = 0;
checksum =(byte) (((buffer[9]&0xf0)>>4)^(buffer[10]&0x0f));
if (checksum != 0x1B) //如果数据校验失败，丢弃这一包数据
{
buffer.RemoveRange(0, 12);//从缓存中删除错误数据
continue;//继续下一次循环
}
//至此，已经被找到了一条完整数据。我们将数据直接分析，或是缓存起来一起分析
//我们这里采用的办法是缓存一次，好处就是如果你某种原因，数据堆积在缓存buffer中
//已经很多了，那你需要循环的找到最后一组，只分析最新数据，过往数据你已经处理不及时
//了，就不要浪费更多时间了，这也是考虑到系统负载能够降低。
buffer.CopyTo(0, binary_data_1, 0, 12);//复制一条完整数据到具体的数据缓存
data_1_catched = true;
buffer.RemoveRange(0, 12);//正确分析一条数据，从缓存中移除数据。
}
else
{
//这里是很重要的，如果数据开始不是头，则删除数据
buffer.RemoveAt(0);
}
}
//分析数据
if (data_1_catched)
{
//我们的数据都是定好格式的，所以当我们找到分析出的数据1，就知道固定位置一定是这些数据，我们只要显示就可以了
string data = binary_data_1[3].ToString("X2") + " " + binary_data_1[4].ToString("X2") + " " +
binary_data_1[5].ToString("X2") + " " + binary_data_1[6].ToString("X2") + " " +
binary_data_1[7].ToString("X2");
//更新界面
this.Invoke((EventHandler)(delegate { txData.Text = data; }));
}
//如果需要别的协议，只要扩展这个data_n_catched就可以了。往往我们协议多的情况下，还会包含数据编号，给来的数据进行
//编号，协议优化后就是： 头+编号+长度+数据+校验
//</协议解析>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
builder.Clear();//清除字符串构造器的内容
//因为要访问ui资源，所以需要使用invoke方式同步ui。
this.Invoke((EventHandler)(delegate
{
//判断是否是显示为16禁止
if (checkBoxHexView.Checked)
{
//依次的拼接出16进制字符串
foreach (byte b in buf)
{
builder.Append(b.ToString("X2") + " ");
}
}
else
{
//直接按ASCII规则转换成字符串
builder.Append(Encoding.ASCII.GetString(buf));
}
//追加的形式添加到文本框末端，并滚动到最后。
this.txGet.AppendText(builder.ToString());
//修改接收计数
labelGetCount.Text = "Get:" + received_count.ToString();
}));
}
finally
{
Listening = false;//我用完了，ui可以关闭串口了。
}
#1
serialPort1_DataReceived
不能保证你收到3个字节才触发执行
有可能只收到了1个字节,它就执行了
于是你数组里其中1个字节是新的,而另外2个是上次收到的
你先把收到的数据放List<byte>里,判断它足够3个了,再处理,处理完删除前3个,继续往里放新的数据
不能保证你收到3个字节才触发执行
有可能只收到了1个字节,它就执行了
于是你数组里其中1个字节是新的,而另外2个是上次收到的
你先把收到的数据放List<byte>里,判断它足够3个了,再处理,处理完删除前3个,继续往里放新的数据
#2
此外,你协议里应该有头有尾,不要就发3个字节的数据
那样你没法区分什么时候是开始,什么时候算结束
比如人家给你发的是1,2,3,1,2,3,本来是连续两组数据,数值是一样的
结果可能你收到的时候是这样收的:2,3,1
那样你没法区分什么时候是开始,什么时候算结束
比如人家给你发的是1,2,3,1,2,3,本来是连续两组数据,数值是一样的
结果可能你收到的时候是这样收的:2,3,1
#3
搜一搜modbus rtu
参考人家的协议是怎么定义的
你也可以自定义一种协议
但是起码要能区分从哪里算开始,哪些是数据,到哪里是结尾了
参考人家的协议是怎么定义的
你也可以自定义一种协议
但是起码要能区分从哪里算开始,哪些是数据,到哪里是结尾了
#4
我这个程序是一直运行接收单片机传来的数组，能不能给个接收的例子，我刚学c#，不太懂你说的
#5
读写串口的例子
你可以参考其中API,同步读串口的例子,这样可以有效的控制2次间隔发送的数据粘包的问题
但是串口不同于TCP协议,它不是安全的传输方式,受干扰很容易造成数据错乱
你的协议里没有校验,那么就很可能造成数据波动很大
不行程序判断一下跟上次的数据差异太大就丢弃好了
你可以参考其中API,同步读串口的例子,这样可以有效的控制2次间隔发送的数据粘包的问题
但是串口不同于TCP协议,它不是安全的传输方式,受干扰很容易造成数据错乱
你的协议里没有校验,那么就很可能造成数据波动很大
不行程序判断一下跟上次的数据差异太大就丢弃好了
#6
而且串口数据没有"包"的概念,它是一个字节一个字节发送,一个字节一个字节接收的
你得自己判断什么时候算一组数据,什么时候它是下一组数据了
你得自己判断什么时候算一组数据,什么时候它是下一组数据了
#7
我用的是serialport
#8
一样的.
serialport其实也是封装的API.
只不过封装完了之后,有便利,也有BUG.所以保留API的方式有时候能派上用处
我是让你参考写法,不是让你copy代码
serialport其实也是封装的API.
只不过封装完了之后,有便利,也有BUG.所以保留API的方式有时候能派上用处
我是让你参考写法,不是让你copy代码
#9
这个真没看懂....我刚学
#10
你的计算公式需要单片机发来的三个字节的数吧，但实际上有时候单片机发过来一个字节的时候serialPort1_DataReceived就会执行，这样你那个pulse=pl[0]*100+pl[1]+pl[2];访问pl数组不就越界了吗？
#11
不是越界吧，是用了上次的数据吧
#12
看不懂就没啥办法了
恶补基础呗
给了代码还看不懂,真心没法再帮了
恶补基础呗
给了代码还看不懂,真心没法再帮了
#13
有没有再简单一些的代码
#14
这已经够简单的了,收到什么就显示什么
还没做复杂协议判断头尾,判断数据是否合法,判断校验是否正确之类的呢
还没做复杂协议判断头尾,判断数据是否合法,判断校验是否正确之类的呢
#15
有越界情况，也有你说的情况，看来你很明白了。既然明白了问题根源，解决方案应该也有了。
#16
没有啊，我还没找到解决办法呢
#17
//从RS232读取数据
//ComPort: 0:COM1 1:COM2
//Kind: 0:从设备接收字符串 1:从产品接收多字节数据,并转换为字符串输出.
public string ReadRS232(int ComPort, int Kind)
{
string TempStr = "";
try
{
if (Kind == 0)
{
switch (ComPort)
{
case 0:
if (!com.serialPort1.IsOpen) com.serialPort1.Open();
if (!(com.serialPort1.BaudRate == 9600)) com.serialPort1.BaudRate = 9600;
if (!(com.serialPort1.DataBits == 8)) com.serialPort1.DataBits = 8;
if (!(com.serialPort1.StopBits == System.IO.Ports.StopBits.One)) com.serialPort1.StopBits = System.IO.Ports.StopBits.One;
if (!(com.serialPort1.Parity == System.IO.Ports.Parity.None)) com.serialPort1.Parity = System.IO.Ports.Parity.None;
if (com.serialPort1.BytesToRead > 0)
TempStr = com.serialPort1.ReadExisting();
com.serialPort1.DiscardInBuffer();
com.serialPort1.DiscardOutBuffer();
break;
case 1:
以前用的，读取返回字符串。
#18
不明白你的需求，是每取三个字节处理一次还是要做更多处理。
如果是三个字节处理一次，可试试如下代码：
如果串口是连续发送数据，那么可能出现缓冲池每次读取到超过三个字节数据的问题，可通过嵌套来进行重复计算。
如果是三个字节处理一次，可试试如下代码：
如果串口是连续发送数据，那么可能出现缓冲池每次读取到超过三个字节数据的问题，可通过嵌套来进行重复计算。
//建立一个数据缓冲池，每次串口收到数据，自动添加到缓冲池尾，数据从缓冲池头读取，读取几位删除几位
private StringBuilder strLst;
private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
int n = sPort.BytesToRead;
byte[] buf = new byte[n];
serialPort1.Read(buf, 0, n);
this.Invoke((EventHandler)(delegate
{
foreach (byte b in buf)
{
strLst.Append(b.ToString("X2") + " ");
}
//如果缓冲池获取的数据小于三个字节，则继续等待，直到获取到三个以上字节
if (strLst.Count < 3)
{
return;
}
else
{
MyFunction(strLst);
}
}));
}
private void MyFunction(stringBuilder pl)
{
pulse=int.parse(pl[0].Text)*100+int.parse(pl[1].Text)+int.parse(pl[2].Text);
//缓冲池删除三个字节，判断剩余数量是否有三个字节，有则重新计算，知道缓冲池内数据长度小于三个字节
pl.RemoveRange(0, 3)
if(pl.Count > 3)
{
MyFunction(pl)
}
}
#19
两种方案
1.设计数据传输协议，比如你需要的数据是1、2、3，但单片机应该发送这样一组数据，b,1,2,3,e，b表示begin，e表示结束，这样，serialPort1_DataReceived中就可以根据接收到的数据做相应的处理，保证完全收到一组正常数据后在拿1,2,3去进行计算。当然，协议设计部分只是简单举一个例子，协议具体格式你自己定；
2.我想你不会选择方案1，那么我再说一个更简单的。定义一个类成员变量，list<int> datalist = new .....，serialPort1_DataReceived中收到数据后，把数据追加到datalist中，再判断datalist的长度，如果>=3，那么拿出下标0-2的数据进行计算，计算后将0-2的数据删除。
#20
说那么多，其实就是TCP粘包了！
#21
怎么解决啊？
#22
那删除完呢，后边的数应该放到0-2中吧
#23
工业串口和网络软件通讯平台（下载）
http://www.bmpj.net/index.php?m=product&f=view&id=1
看看这个，你需要不！！！
http://www.bmpj.net/index.php?m=product&f=view&id=1
看看这个，你需要不！！！
#24
你可以试验一下
#25
LS那几位给方案本质上就是组包和拆包的 其实就是TCP粘包导致的
TCP解决方式有很多种，
这个文章是我写的
你可以参考下，不一定按照我的方法来，你要是懂了TCP粘包的原理，自己都能写了
http://www.cnblogs.com/wangjun8868/p/4380187.html
#26
按你上面的代码，不能光判断接收数据大于0就处理，如果一次只传来一个数据，这样你的代码仍然会处理，但是在后面的代码中，可能会越界。
对于你说的之前的数据参与到操作中来，你每次对数据处理完了，清空一下数据，就不会出现重复数据操作的情况了。
针对你上面的代码，简单理解是只针对三个数据的接收处理，简单点你把那个限制规定为3（在没有头尾，长度，校验等的规定下），不到3个数据不处理，试试。不过这种情况，是上传数据端，不会连续发送数据。
如果大于3个数据的情况，可以像上面同志们说的，先存起来，再处理。
对于你说的之前的数据参与到操作中来，你每次对数据处理完了，清空一下数据，就不会出现重复数据操作的情况了。
针对你上面的代码，简单理解是只针对三个数据的接收处理，简单点你把那个限制规定为3（在没有头尾，长度，校验等的规定下），不到3个数据不处理，试试。不过这种情况，是上传数据端，不会连续发送数据。
如果大于3个数据的情况，可以像上面同志们说的，先存起来，再处理。
#27
你是用 bytes = serialPort1.BytesToRead;//读取串口中的数据 的吗？
#28
Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。
int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
received_count += n;//增加接收计数
comm.Read(buf, 0, n);//读取缓冲数据
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//<协议解析>
bool data_1_catched = false;//缓存记录数据是否捕获到
//1.缓存数据
buffer.AddRange(buf);
//2.完整性判断
while (buffer.Count >= 12)//至少要包含头（2字节）+长度（1字节）+校验（1字节）
{
//请不要担心使用>=，因为>=已经和>,<,=一样，是独立操作符，并不是解析成>和=2个符号
//2.1 查找数据头
if (buffer[0] == 0x02 && buffer[11] == 0x03)
{
//2.2 探测缓存数据是否有一条数据的字节，如果不够，就不用费劲的做其他验证了
//前面已经限定了剩余长度>=12，那我们这里一定能访问到buffer[2]这个长度
//int len = buffer[2];//数据长度
//数据完整判断第一步，长度是否足够
//len是数据段长度,4个字节是while行注释的3部分长度
if (buffer.Count < 12) break;//数据不够的时候什么都不做
//这里确保数据长度足够，数据头标志找到，我们开始计算校验
//2.3 校验数据，确认数据正确
//异或校验，逐个字节异或得到校验码
byte checksum = 0;
checksum =(byte) (((buffer[9]&0xf0)>>4)^(buffer[10]&0x0f));
if (checksum != 0x1B) //如果数据校验失败，丢弃这一包数据
{
buffer.RemoveRange(0, 12);//从缓存中删除错误数据
continue;//继续下一次循环
}
//至此，已经被找到了一条完整数据。我们将数据直接分析，或是缓存起来一起分析
//我们这里采用的办法是缓存一次，好处就是如果你某种原因，数据堆积在缓存buffer中
//已经很多了，那你需要循环的找到最后一组，只分析最新数据，过往数据你已经处理不及时
//了，就不要浪费更多时间了，这也是考虑到系统负载能够降低。
buffer.CopyTo(0, binary_data_1, 0, 12);//复制一条完整数据到具体的数据缓存
data_1_catched = true;
buffer.RemoveRange(0, 12);//正确分析一条数据，从缓存中移除数据。
}
else
{
//这里是很重要的，如果数据开始不是头，则删除数据
buffer.RemoveAt(0);
}
}
//分析数据
if (data_1_catched)
{
//我们的数据都是定好格式的，所以当我们找到分析出的数据1，就知道固定位置一定是这些数据，我们只要显示就可以了
string data = binary_data_1[3].ToString("X2") + " " + binary_data_1[4].ToString("X2") + " " +
binary_data_1[5].ToString("X2") + " " + binary_data_1[6].ToString("X2") + " " +
binary_data_1[7].ToString("X2");
//更新界面
this.Invoke((EventHandler)(delegate { txData.Text = data; }));
}
//如果需要别的协议，只要扩展这个data_n_catched就可以了。往往我们协议多的情况下，还会包含数据编号，给来的数据进行
//编号，协议优化后就是： 头+编号+长度+数据+校验
//</协议解析>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
builder.Clear();//清除字符串构造器的内容
//因为要访问ui资源，所以需要使用invoke方式同步ui。
this.Invoke((EventHandler)(delegate
{
//判断是否是显示为16禁止
if (checkBoxHexView.Checked)
{
//依次的拼接出16进制字符串
foreach (byte b in buf)
{
builder.Append(b.ToString("X2") + " ");
}
}
else
{
//直接按ASCII规则转换成字符串
builder.Append(Encoding.ASCII.GetString(buf));
}
//追加的形式添加到文本框末端，并滚动到最后。
this.txGet.AppendText(builder.ToString());
//修改接收计数
labelGetCount.Text = "Get:" + received_count.ToString();
}));
}
finally
{
Listening = false;//我用完了，ui可以关闭串口了。
}
int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
received_count += n;//增加接收计数
comm.Read(buf, 0, n);//读取缓冲数据
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//<协议解析>
bool data_1_catched = false;//缓存记录数据是否捕获到
//1.缓存数据
buffer.AddRange(buf);
//2.完整性判断
while (buffer.Count >= 12)//至少要包含头（2字节）+长度（1字节）+校验（1字节）
{
//请不要担心使用>=，因为>=已经和>,<,=一样，是独立操作符，并不是解析成>和=2个符号
//2.1 查找数据头
if (buffer[0] == 0x02 && buffer[11] == 0x03)
{
//2.2 探测缓存数据是否有一条数据的字节，如果不够，就不用费劲的做其他验证了
//前面已经限定了剩余长度>=12，那我们这里一定能访问到buffer[2]这个长度
//int len = buffer[2];//数据长度
//数据完整判断第一步，长度是否足够
//len是数据段长度,4个字节是while行注释的3部分长度
if (buffer.Count < 12) break;//数据不够的时候什么都不做
//这里确保数据长度足够，数据头标志找到，我们开始计算校验
//2.3 校验数据，确认数据正确
//异或校验，逐个字节异或得到校验码
byte checksum = 0;
checksum =(byte) (((buffer[9]&0xf0)>>4)^(buffer[10]&0x0f));
if (checksum != 0x1B) //如果数据校验失败，丢弃这一包数据
{
buffer.RemoveRange(0, 12);//从缓存中删除错误数据
continue;//继续下一次循环
}
//至此，已经被找到了一条完整数据。我们将数据直接分析，或是缓存起来一起分析
//我们这里采用的办法是缓存一次，好处就是如果你某种原因，数据堆积在缓存buffer中
//已经很多了，那你需要循环的找到最后一组，只分析最新数据，过往数据你已经处理不及时
//了，就不要浪费更多时间了，这也是考虑到系统负载能够降低。
buffer.CopyTo(0, binary_data_1, 0, 12);//复制一条完整数据到具体的数据缓存
data_1_catched = true;
buffer.RemoveRange(0, 12);//正确分析一条数据，从缓存中移除数据。
}
else
{
//这里是很重要的，如果数据开始不是头，则删除数据
buffer.RemoveAt(0);
}
}
//分析数据
if (data_1_catched)
{
//我们的数据都是定好格式的，所以当我们找到分析出的数据1，就知道固定位置一定是这些数据，我们只要显示就可以了
string data = binary_data_1[3].ToString("X2") + " " + binary_data_1[4].ToString("X2") + " " +
binary_data_1[5].ToString("X2") + " " + binary_data_1[6].ToString("X2") + " " +
binary_data_1[7].ToString("X2");
//更新界面
this.Invoke((EventHandler)(delegate { txData.Text = data; }));
}
//如果需要别的协议，只要扩展这个data_n_catched就可以了。往往我们协议多的情况下，还会包含数据编号，给来的数据进行
//编号，协议优化后就是： 头+编号+长度+数据+校验
//</协议解析>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
builder.Clear();//清除字符串构造器的内容
//因为要访问ui资源，所以需要使用invoke方式同步ui。
this.Invoke((EventHandler)(delegate
{
//判断是否是显示为16禁止
if (checkBoxHexView.Checked)
{
//依次的拼接出16进制字符串
foreach (byte b in buf)
{
builder.Append(b.ToString("X2") + " ");
}
}
else
{
//直接按ASCII规则转换成字符串
builder.Append(Encoding.ASCII.GetString(buf));
}
//追加的形式添加到文本框末端，并滚动到最后。
this.txGet.AppendText(builder.ToString());
//修改接收计数
labelGetCount.Text = "Get:" + received_count.ToString();
}));
}
finally
{
Listening = false;//我用完了，ui可以关闭串口了。
}