C# Serialport串口通信，接收数据丢失

[偶是菜鸟]

用DataReceived方法接收数据时有时候会丢失，尤其是在debug的时候，有时候甚至多定义几个变量，数据接收也会出现丢失，有什么办法可以解决吗？

[一只啃书的老鼠]

好吧，这不是协议的问题！ 关于你这个具体问题，我给你个建议： 1：接收门限设为 1 ，建立缓存，接收的函数只负责接收，这里门限为1应该还是不会卡！！！，只是每次读取数据的时候，要读取串口接收缓存中已有数据，也就是你的代码那句！！！ 2、处理线程里面，可以进行判断，是指定的指令，则对串口写回应指令。 3、文本框仅仅用来show信息，不要将其当作“缓存”来用，ok? 如果还不清楚，我上代码！！！！

[vo__ov]

串口传输是快速的，要是数据接收不及，会放到缓冲区，当新的数据来了，缓冲区还没取走数据，旧数据就被新数据刷掉了 楼上有人说了要快速接收，别在接收时磨，速战速决呀

[一只啃书的老鼠]

另外，你DEBUG的时候，如果有断点，那很可能是会接收不到完整数据的，因为你程序“卡”在了断点，而上位机数据可能源源不断的来袭！！！ 这个情况要看你们自己定义的通信协议，也就是你说的上位机来个指令，下位机回复，然后上位如何来数据？是源源不断的大量数据，还是依旧这样你来我往？ 具体情况，要具体分析吧

[偶是菜鸟]

引用 39 楼 goodhtml 的回复:

嘿嘿，这个问题正好是我之前所遇到的。你应该清空缓冲区，再读取。你还可以在接收的时候，进行校验。这样就可以避免错误。

只要返回我需要的值，就认为成功了，这个难道不算校验？

[jhdxhj]

楼上兄弟说的很对..

[偶是菜鸟]

引用 41 楼 jhdxhj 的回复:

楼上兄弟说的很对..

[Zanvimocvy]

引用 42 楼 fangwei198712 的回复:

引用 41 楼 jhdxhj 的回复:

楼上兄弟说的很对..

好吧，楼主你就自个一个人解决去吧。就当大家说废话了。

[偶是菜鸟]

引用 59 楼 u010637722 的回复:

好吧，这不是协议的问题！ 关于你这个具体问题，我给你个建议： 1：接收门限设为 1 ，建立缓存，接收的函数只负责接收，这里门限为1应该还是不会卡！！！，只是每次读取数据的时候，要读取串口接收缓存中已有数据，也就是你的代码那句！！！ 2、处理线程里面，可以进行判断，是指定的指令，则对串口写回应指令。 3、文本框仅仅用来show信息，不要将其当作“缓存”来用，ok? 如果还不清楚，我上代码！！！！

求缓存代码~~

[偶是菜鸟]

引用 61 楼 u010637722 的回复:

另外，你DEBUG的时候，如果有断点，那很可能是会接收不到完整数据的，因为你程序“卡”在了断点，而上位机数据可能源源不断的来袭！！！ 这个情况要看你们自己定义的通信协议，也就是你说的上位机来个指令，下位机回复，然后上位如何来数据？是源源不断的大量数据，还是依旧这样你来我往？ 具体情况，要具体分析吧

看了下协议（xmodem）应该是一来一往的，上位机传一些指令，下位机接收后处理，处理后返回数据到上位机，PS：有人说协议和串口没有关系，只要把数据流传过去，下位机根据已定义协议的直接解析。

[一只啃书的老鼠]

楼主，我这个思路绝对可以解决问题： 1、首先，建立缓存，接收数据直接入缓存，不要处理，委托之类！！！ 2、改动接收门限，不要用默认的1！！！！ 3，数据处理转换操作，不要在接收里面进行！！！！可以建立一个线程，检测步骤1里面的缓存，有数据就处理！！！ 其他不多言！！！ 我做过串口这块！！，绝对可以帮到你！！！

[偶是菜鸟]

引用 65 楼 u010637722 的回复:

     public class Buffer
    {
         const int Size  =4096;//缓存大小
         byte[] buffer = new byte[Size];

         int InPtr = 0; //当前数据入缓存的起始位置
         int OutPtr = 0;     //当前缓存取数据起始位置（也就是未处理的数据起始位置）
         int dataLength = 0; //当前缓存中数据长度
         int dataSpace = Size; //当前缓存还可存入的数据

         public void DataIn(byte[] data)
         {
             if (data.Length <= dataSpace)
             {
                 for (int i = 0; i < data.Length; i++)
                 {
                     buffer[InPtr] = data[i];                     
                 }
                 InPtr = (InPtr + data.Length) % Size;
                 dataLength = (dataLength + data.Length);
                 dataSpace = dataSpace - data.Length;
 
             }
         }
         public byte[] DataOut(int Length)
         {
             if (Length <= dataLength && Length>0)
             {
                 byte[] data = new byte[Length];
                 for (int i = 0; i < Length; i++)
                 {
                     data[i] = buffer[(OutPtr + i) % Size];
                 }
                 OutPtr = (OutPtr + Length) % Size;
                 dataLength = (dataLength -Length);
                 dataSpace = dataSpace+Length;
             }
         }
    }

我把缓存类的大体结构代码给你，我自己的是泛型,并且有些乱七八糟的事件等之类，你这里没有必要，只需处理字节串

非常感谢~~~~~~~~~ 还有个疑惑①这样放在缓冲区是不是效率也比较低（还没有实验，下位机被人拿走了。。），因为传输的比特率比较大115200;②用一个timer控件可以不？（线程不太会）;③串口的缓冲区size最大4096吗？

[偶是菜鸟]

看见最近好多人在问串口的问题，加分到100，希望大拿们帮下我们这些菜鸟

[一只啃书的老鼠]

引用 66 楼 fangwei198712 的回复:

[quote=引用 65 楼 u010637722 的回复:]

     public class Buffer
    {
         const int Size  =4096;//缓存大小
         byte[] buffer = new byte[Size];

         int InPtr = 0; //当前数据入缓存的起始位置
         int OutPtr = 0;     //当前缓存取数据起始位置（也就是未处理的数据起始位置）
         int dataLength = 0; //当前缓存中数据长度
         int dataSpace = Size; //当前缓存还可存入的数据

         public void DataIn(byte[] data)
         {
             if (data.Length <= dataSpace)
             {
                 for (int i = 0; i < data.Length; i++)
                 {
                     buffer[InPtr] = data[i];                     
                 }
                 InPtr = (InPtr + data.Length) % Size;
                 dataLength = (dataLength + data.Length);
                 dataSpace = dataSpace - data.Length;
 
             }
         }
         public byte[] DataOut(int Length)
         {
             if (Length <= dataLength && Length>0)
             {
                 byte[] data = new byte[Length];
                 for (int i = 0; i < Length; i++)
                 {
                     data[i] = buffer[(OutPtr + i) % Size];
                 }
                 OutPtr = (OutPtr + Length) % Size;
                 dataLength = (dataLength -Length);
                 dataSpace = dataSpace+Length;
             }
         }
    }

我把缓存类的大体结构代码给你，我自己的是泛型,并且有些乱七八糟的事件等之类，你这里没有必要，只需处理字节串

非常感谢~~~~~~~~~ 还有个疑惑①这样放在缓冲区是不是效率也比较低（还没有实验，下位机被人拿走了。。），因为传输的比特率比较大115200;②用一个timer控件可以不？（线程不太会）;③串口的缓冲区size最大4096吗？[/quote] 1、这个缓存的大小由你设定！根据实际情况，你可以把缓存大小设为100字节或更小。 2、效率低在那个地方？我不明白你问的！！建立一个线程，监听这个缓存，缓存的dataLength>0,即处理，基本上，缓存中一有数据进入，该线程就取出数据进行处理。 没必要用TIMER,好吧，我把代码都放上来，你把分给我吧

[偶是菜鸟]

引用 68 楼 u010637722 的回复:

[quote=引用 66 楼 fangwei198712 的回复:] [quote=引用 65 楼 u010637722 的回复:]

     public class Buffer
    {
         const int Size  =4096;//缓存大小
         byte[] buffer = new byte[Size];

         int InPtr = 0; //当前数据入缓存的起始位置
         int OutPtr = 0;     //当前缓存取数据起始位置（也就是未处理的数据起始位置）
         int dataLength = 0; //当前缓存中数据长度
         int dataSpace = Size; //当前缓存还可存入的数据

         public void DataIn(byte[] data)
         {
             if (data.Length <= dataSpace)
             {
                 for (int i = 0; i < data.Length; i++)
                 {
                     buffer[InPtr] = data[i];                     
                 }
                 InPtr = (InPtr + data.Length) % Size;
                 dataLength = (dataLength + data.Length);
                 dataSpace = dataSpace - data.Length;
 
             }
         }
         public byte[] DataOut(int Length)
         {
             if (Length <= dataLength && Length>0)
             {
                 byte[] data = new byte[Length];
                 for (int i = 0; i < Length; i++)
                 {
                     data[i] = buffer[(OutPtr + i) % Size];
                 }
                 OutPtr = (OutPtr + Length) % Size;
                 dataLength = (dataLength -Length);
                 dataSpace = dataSpace+Length;
             }
         }
    }

我把缓存类的大体结构代码给你，我自己的是泛型,并且有些乱七八糟的事件等之类，你这里没有必要，只需处理字节串

非常感谢~~~~~~~~~ 还有个疑惑①这样放在缓冲区是不是效率也比较低（还没有实验，下位机被人拿走了。。），因为传输的比特率比较大115200;②用一个timer控件可以不？（线程不太会）;③串口的缓冲区size最大4096吗？[/quote] 1、这个缓存的大小由你设定！根据实际情况，你可以把缓存大小设为100字节或更小。 2、效率低在那个地方？我不明白你问的！！建立一个线程，监听这个缓存，缓存的dataLength>0,即处理，基本上，缓存中一有数据进入，该线程就取出数据进行处理。 没必要用TIMER,好吧，我把代码都放上来，你把分给我吧[/quote]效率低，是一次接收字节比较多（4000多吧）的时候，用DataIn（）方法接收会不会要时间很多，这样又会出现数据丢失吧

[一只啃书的老鼠]

我用这个思路，串口完全没问题，网络数据也丝毫不惧！！！，比如，网络数据包，一秒10包，一包1400个字节，就这样弄完全没问题，比你串口数据量大多了吧！！，你在全局声明一个缓存类变量，你把串口接收的输入直接调用buffer.DataIn();数据就进这个缓存了。然后接收这块就OK。 缓存监听这个可以这样写,在主界面下面建立一个线程，线程的执行函数类似这样

 bool RequestStop = false;
        int L = 10;
        void Process()
        {
            while (!RequestStop)
            {
                while (buffer.dataLength > 0)
                {
                    byte[] data = buffer.DataOut(L );
                    DoWork(data);//处理数据，并做想要做的事情！！
                }
            }
        }

这样一来，你串口的接收是没有问题了，因为串口的接收不会“卡”，但是这样会有另外一个问题，那就是在这个线程里面如果操作主界面的文本框呢？ 对，你很聪敏，你可以用委托，也就是你自己最上面串口接收那块处理的代码块！ 当然还有另外一个思路：事件委托，利用事件参数传递数据，这，不属于这个范围了。

[一只啃书的老鼠]

忘了说，上面，设计的一个bool变量用于控制线程是否退出。 另一个L，则要求你根据自己实际需求，或者你们自己的通信协议进行设定。 再说一边，这么做的总体思路是： 1、接收数据的函数，只负责将接收到的数据入缓存。 2、在处理线程中，每当缓存中有数据，即可以开始想要的处理，这个想要的处理，得根据你的实际需求，比如， a、你串口上位机来一个指令，那么，你根据自己的协议，在这个缓存中去匹配这个指令，根据指令，再回发什么数据 b、如果上位发来的是一帧帧的数据，那么你可以在这个缓存中去提取帧 总之，你接收到的串口数据都在这个缓存变量中了，怎么处理，你看着办好了。 这个缓存是个循环数组，来的数据一直往里面写，写到尾巴又自动回到开始 处理线程一直从这个缓存取数据。你可以想象下，这个缓存，就好比两个人在圆形赛道上跑步，后面的人（OutPtr）一直追赶前面的人（InPtr），前面的人一直往前跑。如果后面的人贴着前面的人了，他就停止跑步！！ 出现问题的可能就在于，来的数据特别快特别多，也就是前面跑的超了后面这个人一圈，那么这就会出现数据处理不过来了，这种情况在串口这种数据量下，是不可能的！！！ 在大数据量下，如果出现这情况，那表示，你可以加大缓存，如果缓存很大还不性，那你该换CPU 了，我唉没遇到这样的情况！

[一只啃书的老鼠]

引用 63 楼 fangwei198712 的回复:

[quote=引用 61 楼 u010637722 的回复:] 另外，你DEBUG的时候，如果有断点，那很可能是会接收不到完整数据的，因为你程序“卡”在了断点，而上位机数据可能源源不断的来袭！！！ 这个情况要看你们自己定义的通信协议，也就是你说的上位机来个指令，下位机回复，然后上位如何来数据？是源源不断的大量数据，还是依旧这样你来我往？ 具体情况，要具体分析吧

看了下协议（xmodem）应该是一来一往的，上位机传一些指令，下位机接收后处理，处理后返回数据到上位机，PS：有人说协议和串口没有关系，只要把数据流传过去，下位机根据已定义协议的直接解析。[/quote] 协议与串口无关，串口只管接收，至于协议，由后续处理线程里面判断！！

[一只啃书的老鼠]

     public class Buffer
    {
         const int Size  =4096;//缓存大小
         byte[] buffer = new byte[Size];

         int InPtr = 0; //当前数据入缓存的起始位置
         int OutPtr = 0;     //当前缓存取数据起始位置（也就是未处理的数据起始位置）
         int dataLength = 0; //当前缓存中数据长度
         int dataSpace = Size; //当前缓存还可存入的数据

         public void DataIn(byte[] data)
         {
             if (data.Length <= dataSpace)
             {
                 for (int i = 0; i < data.Length; i++)
                 {
                     buffer[InPtr] = data[i];                     
                 }
                 InPtr = (InPtr + data.Length) % Size;
                 dataLength = (dataLength + data.Length);
                 dataSpace = dataSpace - data.Length;
 
             }
         }
         public byte[] DataOut(int Length)
         {
             if (Length <= dataLength && Length>0)
             {
                 byte[] data = new byte[Length];
                 for (int i = 0; i < Length; i++)
                 {
                     data[i] = buffer[(OutPtr + i) % Size];
                 }
                 OutPtr = (OutPtr + Length) % Size;
                 dataLength = (dataLength -Length);
                 dataSpace = dataSpace+Length;
             }
         }
    }

我把缓存类的大体结构代码给你，我自己的是泛型,并且有些乱七八糟的事件等之类，你这里没有必要，只需处理字节串

[一只啃书的老鼠]

引用 69 楼 fangwei198712 的回复:

[quote=引用 68 楼 u010637722 的回复:] [quote=引用 66 楼 fangwei198712 的回复:] [quote=引用 65 楼 u010637722 的回复:]

     public class Buffer
    {
         const int Size  =4096;//缓存大小
         byte[] buffer = new byte[Size];

         int InPtr = 0; //当前数据入缓存的起始位置
         int OutPtr = 0;     //当前缓存取数据起始位置（也就是未处理的数据起始位置）
         int dataLength = 0; //当前缓存中数据长度
         int dataSpace = Size; //当前缓存还可存入的数据

         public void DataIn(byte[] data)
         {
             if (data.Length <= dataSpace)
             {
                 for (int i = 0; i < data.Length; i++)
                 {
                     buffer[InPtr] = data[i];                     
                 }
                 InPtr = (InPtr + data.Length) % Size;
                 dataLength = (dataLength + data.Length);
                 dataSpace = dataSpace - data.Length;
 
             }
         }
         public byte[] DataOut(int Length)
         {
             if (Length <= dataLength && Length>0)
             {
                 byte[] data = new byte[Length];
                 for (int i = 0; i < Length; i++)
                 {
                     data[i] = buffer[(OutPtr + i) % Size];
                 }
                 OutPtr = (OutPtr + Length) % Size;
                 dataLength = (dataLength -Length);
                 dataSpace = dataSpace+Length;
             }
         }
    }

我把缓存类的大体结构代码给你，我自己的是泛型,并且有些乱七八糟的事件等之类，你这里没有必要，只需处理字节串

非常感谢~~~~~~~~~ 还有个疑惑①这样放在缓冲区是不是效率也比较低（还没有实验，下位机被人拿走了。。），因为传输的比特率比较大115200;②用一个timer控件可以不？（线程不太会）;③串口的缓冲区size最大4096吗？[/quote] 1、这个缓存的大小由你设定！根据实际情况，你可以把缓存大小设为100字节或更小。 2、效率低在那个地方？我不明白你问的！！建立一个线程，监听这个缓存，缓存的dataLength>0,即处理，基本上，缓存中一有数据进入，该线程就取出数据进行处理。 没必要用TIMER,好吧，我把代码都放上来，你把分给我吧[/quote]效率低，是一次接收字节比较多（4000多吧）的时候，用DataIn（）方法接收会不会要时间很多，这样又会出现数据丢失吧[/quote] 无语，一次接收4000多？你触发门限设为1，有数据一来，就会接收！！！！再多的字节，也是分若干次接收，好不？串口自己也是有缓存的！！ 比如，上位机一下子发10000字节，这10000个字节也是一个个字节来到下位机的好么？下位机一发现到来数据到达接收门限，即触发读串口缓存数据。这个DataIn你可以优化，但对于你这样的串口数据量，完全没压力好么？ 我已经说了网络的每秒14000字节数据，它都没问题好不？ 别跟我扯犊子了，你有疑问很好，BUT，你先明白我说的，然后去尝试后，再发言好么？如果到现在你还不明白按我这思路怎么做，我只能无语。 学习，不是你这样的，上面那么多人提出缓存的解决思路，你有听进去？ 你的分数，我也不要了，你慢慢慢慢琢磨了，我懒得回复了！

[偶是菜鸟]

谢谢大家的帮助，结贴散分