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

偶是菜鸟 2013-06-18 03:14:33

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

...全文

2243 73 打赏收藏转发到动态举报

写回复

用AI写文章

73 条回复

切换为时间正序

请发表友善的回复…

发表回复

偶是菜鸟 2013-06-23

打赏
举报

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

一只啃书的老鼠 2013-06-22

打赏
举报

引用 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，你先明白我说的，然后去尝试后，再发言好么？如果到现在你还不明白按我这思路怎么做，我只能无语。学习，不是你这样的，上面那么多人提出缓存的解决思路，你有听进去？你的分数，我也不要了，你慢慢慢慢琢磨了，我懒得回复了！

一只啃书的老鼠 2013-06-21

打赏
举报


     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;
             }
         }
    }

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

一只啃书的老鼠 2013-06-21

打赏
举报

引用 63 楼 fangwei198712 的回复:

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

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

一只啃书的老鼠 2013-06-21

打赏
举报

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

一只啃书的老鼠 2013-06-21

打赏
举报

我用这个思路，串口完全没问题，网络数据也丝毫不惧！！！，比如，网络数据包，一秒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);//处理数据，并做想要做的事情！！
                }
            }
        }

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

偶是菜鸟 2013-06-21

打赏
举报

引用 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;
             }
         }
    }

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

一只啃书的老鼠 2013-06-21

打赏
举报

引用 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;
             }
         }
    }

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

偶是菜鸟 2013-06-21

打赏
举报

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

偶是菜鸟 2013-06-21

打赏
举报

引用 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吗？

一只啃书的老鼠 2013-06-20

打赏
举报

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

偶是菜鸟 2013-06-20

打赏
举报

引用 61 楼 u010637722 的回复:

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

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

偶是菜鸟 2013-06-20

打赏
举报

引用 59 楼 u010637722 的回复:

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

求缓存代码~~

「已注销」 2013-06-20

打赏
举报

引用 42 楼 fangwei198712 的回复:

引用 41 楼 jhdxhj 的回复:
楼上兄弟说的很对..

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

偶是菜鸟 2013-06-20

打赏
举报

引用 41 楼 jhdxhj 的回复:

楼上兄弟说的很对..

jhdxhj 2013-06-20

打赏
举报

楼上兄弟说的很对..

偶是菜鸟 2013-06-20

打赏
举报

引用 39 楼 goodhtml 的回复:

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

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

一只啃书的老鼠 2013-06-20

打赏
举报

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

vo__ov 2013-06-20

打赏
举报

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

一只啃书的老鼠 2013-06-20

打赏
举报

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

加载更多回复（53）

滞环控制simulink仿真模型

打开链接下载源码： https://pan.quark.cn/s/589796089f72 C++课程设计任务列表，涵盖以下内容：1、识别并显示10至99范围内，各位数乘积超过各位数和的数值，例如数字12不满足条件，因为1乘以2小于1加2，故不输出；而数字27满足条件，因为2乘以7大于2加7，因此需要输出该数。2、开发一个功能，用于从用户输入的任意数量实数中找出最大值与最小值：首先要求用户输入一个正整数n，代表数值的个数，随后用户可输入任意n个实数，程序需找出这n个数中的最大值和最小值并将它们展示出来。3、实现两个已排序数组的合并操作：设有数组A和B，且假设这两个数组的元素均已按照降序排列。编写程序将A和B合并成一个新的数组C，并确保C中的元素同样保持降序排列。int A[10]={123, 86,80, 49,33,15,7,0,-1,-3}；int B[10]={100,64,51,50,27,19,15,12,5,2}；4、设计一个函数，用于计算特定分数序列前n项的总和，该序列为1/2,1/3,1/4,1/5,1/6,1/7,...。要求在主程序中提示用户输入一个整数n，并验证输入的合法性（n需大于1方为有效），若输入合法，则调用求和函数并显示计算结果。5、编写一个程序，计算两个用户输入日期之间的天数差：用户需以year1，month1，day1和year2，month2，day2的格式输入两个日期，程序随后计算这两个日期之间的天数间隔，并将结果输出到屏幕上。要求编制具有如下原型的函数difs2Date：long GetDayDifference（int y1,int m1,int d1,int y2,int m2,int d2）；并在主函数中调用此函数，将计...

代码下载地址： https://pan.quark.cn/s/ee8627e4e6d7 ABAP调试器是一种功能强大的工具，可用于在执行期间对ABAP代码进行检验。除了常规的核心功能（例如逐行运行代码以及检验变量、字段符号和引用的值）之外，它还提供了一些辅助性的特性，能够简化并压缩调试会话的时长。并非所有使用者都熟悉这些辅助特性。SAP ABAP调试器是处理和优化ABAP代码开发与维护工作的核心资源，它配备了多样的功能来协助开发人员在运行状态下进行检验和排除故障。此资源着重阐述了ABAP调试器的一些高级特性，涵盖了深入分析调用堆栈、系统级调试、更新会话调试以及提升调试效率的方法。 1. **深入分析调用堆栈**：除了常规的应用程序调试，开发人员有时需要对调用堆栈的内部层级进行深入调试，特别是在错误出现在异步执行的更新处理或系统级程序时。通过启用**系统级调试**，可以访问通常不公开的系统代码，但这也会导致调用堆栈的显著增加，因此需要审慎操作。 2. **系统级调试**：对于不含业务逻辑的系统级程序，开发人员通常无需进行调试。然而，在特定情形下，例如进行错误追踪时，可能需要进入系统代码。借助调试器的“系统调试启用/禁用”选项，可以赋予对系统程序的调试权限。 3. **更新会话调试**：在处理异步更新任务，例如持久化业务数据时，错误可能发生在更新任务内部。激活**更新会话调试**，在更新任务完成后，调试器将自动启动，展示执行路径。比如，在变更成本中心后，通过输入调试指令 "/h" 启动调试，保存后能够看到更新过程中的错误。 4. **分析调用堆栈**：在进行深入调试时，调用堆栈是至关重要的。通过分析调用堆栈，能够定位到引发问题的具体位置，如在VB_V2_NORMAL...

源码链接： https://pan.quark.cn/s/a4b39357ea24 小程序雷达 AI 驱动的小程序生态选型与风险评估工具，把微信小程序开发资源转化为可筛选、可评估、可对比的技术雷达。线上地址主站： Vercel：适合谁正在做微信小程序技术选型的产品、研发和架构团队。需要判断 Taro、uni-app、原生小程序、组件库、云开发和 SDK 风险的团队。需要把历史 awesome 列表转成可筛选、可对比、可验证技术雷达的维护者。可以做什么 Radar：按推荐状态、风险等级、资源类型、分类和适用场景浏览小程序生态资源。 Quick Search：快速搜索资源并跳转常用页面。 Compare：对比 Taro、uni-app、原生小程序等核心方案。 Advisor：输入选型问题，获得推荐结论、适用/不适用条件、迁移成本、下一步和证据来源。 Doctor：粘贴小程序项目配置，识别框架依赖、过时方案和迁移风险。 Weekly：查看小程序生态周报和近期风险信号。数据概览当前数据集中包含 236 个小程序生态资源。完整资源可在 Radar 页面和导出能力中查看。核心样例 Taro ★30.6k+ - 使用 React 的方式开发小程序的框架，同时支持生成多端应用 uni-app ★36.1k+ - 使用 Vue 语法开发小程序、H5、App的统一框架 MPX ★2.1k+ - 增强型小程序框架，深度性能优化，支持跨小程序平台开发，完全兼容原生小程序组件 WePY ★21.7k+ - 支持组件化的小程序开发框架 vant-weapp ★12.3k+ - 高颜值、好用、易扩展的微信小程序 UI 库 tdesign-miniprogram ★1.3...