C# API方式串口读写-阿里云开发者社区

开发者社区> 开发与运维> 正文
登录阅读全文

C# API方式串口读写

简介:

在调试ICU通信设备的时候,由于串口通信老出现故障,所以就怀疑CF实现的SerialPort类是否有问题,所以最后决定用纯API函数实现串口读写。
先从网上搜索相关代码(关键字:C# API 串口),发现网上相关的资料大约来源于一个版本,那就是所谓的msdn提供的样例代码(msdn的具体出处,我没有考证),其它的代码大都是它的变种。
其实这个示例代码是有问题的,也就是说DCB结构体声明的有问题,虽然该代码可以正常通信,不过如果你设置了奇偶校验的话,你会发现奇偶校验无效。
VC中的DCB结构声明如下:
 


  1. typedef struct _DCB {  
  2.     DWORD DCBlength;      /* sizeof(DCB)                     */  
  3.     DWORD BaudRate;       /* Baudrate at which running       */  
  4.     DWORD fBinary: 1;     /* Binary Mode (skip EOF check)    */  
  5.     DWORD fParity: 1;     /* Enable parity checking          */  
  6.     DWORD fOutxCtsFlow:1; /* CTS handshaking on output       */  
  7.     DWORD fOutxDsrFlow:1; /* DSR handshaking on output       */  
  8.     DWORD fDtrControl:2; /* DTR Flow control                */  
  9.     DWORD fDsrSensitivity:1; /* DSR Sensitivity              */  
  10.     DWORD fTXContinueOnXoff: 1; /* Continue TX when Xoff sent */  
  11.     DWORD fOutX: 1;       /* Enable output X-ON/X-OFF        */  
  12.     DWORD fInX: 1;        /* Enable input X-ON/X-OFF         */  
  13.     DWORD fErrorChar: 1; /* Enable Err Replacement          */  
  14.     DWORD fNull: 1;       /* Enable Null stripping           */  
  15.     DWORD fRtsControl:2; /* Rts Flow control                */  
  16.     DWORD fAbortOnError:1; /* Abort all reads and writes on Error */  
  17.     DWORD fDummy2:17;     /* Reserved                        */  
  18.     WORD wReserved;       /* Not currently used              */  
  19.     WORD XonLim;          /* Transmit X-ON threshold         */  
  20.     WORD XoffLim;         /* Transmit X-OFF threshold        */  
  21.     BYTE ByteSize;        /* Number of bits/byte, 4-8        */  
  22.     BYTE Parity;          /* 0-4=None,Odd,Even,Mark,Space    */  
  23.     BYTE StopBits;        /* 0,1,2 = 1, 1.5, 2               */  
  24.     char XonChar;         /* Tx and Rx X-ON character        */  
  25.     char XoffChar;        /* Tx and Rx X-OFF character       */  
  26.     char ErrorChar;       /* Error replacement char          */  
  27.     char EofChar;         /* End of Input character          */  
  28.     char EvtChar;         /* Received Event character        */  
  29.     WORD wReserved1;      /* Fill for now.                   */  
  30. } DCB, *LPDCB;  

 
有问题的代码DCB结构声明如下:
[StructLayout(LayoutKind.Sequential)]
       


  1. public struct DCB  
  2.         {  
  3.             public int DCBlength;  
  4.             public int BaudRate;  
  5.             public int fBinary;  
  6.             public int fParity;  
  7.             public int fOutxCtsFlow;  
  8.             public int fOutxDsrFlow;  
  9.             public int fDtrControl;  
  10.             public int fDsrSensitivity;  
  11.             public int fTXContinueOnXoff;  
  12.             public int fOutX;  
  13.             public int fInX;  
  14.             public int fErrorChar;  
  15.             public int fNull;  
  16.             public int fRtsControl;  
  17.             public int fAbortOnError;  
  18.             public int fDummy2;  
  19.             public uint flags;  
  20.             public ushort wReserved;  
  21.             public ushort XonLim;  
  22.             public ushort XoffLim;  
  23.             public byte ByteSize;  
  24.             public byte Parity;  
  25.             public byte StopBits;  
  26.             public byte XonChar;  
  27.             public byte XoffChar;  
  28.             public byte ErrorChar;  
  29.             public byte EofChar;  
  30.             public byte EvtChar;  
  31.             public ushort wReserved1;  
  32.         }  

对C++比较熟悉网友应该知道,结构体中这种格式的声明,如DWORD fBinary: 1;是以位为单位进行变量设置的,DCB中相关位一共占4个字节,也就是相当于C#中的一个int变量所占的空间。很明显上面的DCB结构会有问题,实际上后面你设置的串口参数,如奇偶校验由于偏移有问题,虽然你设置了,其实都没有设置成功。
其实也不是我说人家的DCB声明错了就错了,在SerialPort类中你就可以找到微软官方自己的DCB声明(需要反编译SerialPort类),声明如下:
[StructLayout(LayoutKind.Sequential)]
       


  1. public struct DCB  
  2.        {  
  3.            public int DCBlength;  
  4.            public int BaudRate;  
  5.            public uint Flags;  
  6.            public ushort wReserved;  
  7.            public ushort XonLim;  
  8.            public ushort XoffLim;  
  9.            public byte ByteSize;  
  10.            public byte Parity;  
  11.            public byte StopBits;  
  12.            public byte XonChar;  
  13.            public byte XoffChar;  
  14.            public byte ErrorChar;  
  15.            public byte EofChar;  
  16.            public byte EvtChar;  
  17.            public ushort wReserved1;  
  18.        }  

并且专门有一个设置位标志的函数,如下:
 


  1. internal void SetDcbFlag(int whichFlag, int setting)  
  2.         {  
  3.             uint num;  
  4.             setting = setting << whichFlag;  
  5.             if ((whichFlag == 4) || (whichFlag == 12))  
  6.             {  
  7.                 num = 3;  
  8.             }  
  9.             else if (whichFlag == 15)  
  10.             {  
  11.                 num = 0x1ffff;  
  12.             }  
  13.             else 
  14.             {  
  15.                 num = 1;  
  16.             }  
  17.             dcb.flags &= ~(num << whichFlag);  
  18.             dcb.flags |= (uint)setting;  
  19.         }  

经过修改能正确运行的API代码如下(注意,由于我是在WinCE平台上运行,所以DLL的路径为"\\windows\\coredll.dll",你修改为"kernel32"后即可在PC机使用):
 


  1. ///<summary>  
  2.     /// API串口类 叶帆修改 http://yfsoft.blog.51cto.com
  3.     ///</summary>  
  4.     public class CommPort  
  5.     {  
  6.         ///<summary>  
  7.         ///端口名称(COM1,COM2...COM4...)  
  8.         ///</summary>  
  9.         public string Port = "COM1:";  
  10.         ///<summary>  
  11.         ///波特率9600  
  12.         ///</summary>  
  13.         public int BaudRate = 9600;  
  14.         ///<summary>  
  15.         ///数据位4-8  
  16.         ///</summary>  
  17.         public byte ByteSize = 8; //4-8   
  18.         ///<summary>  
  19.         ///奇偶校验0-4=no,odd,even,mark,space   
  20.         ///</summary>  
  21.         public byte Parity = 0;   //0-4=no,odd,even,mark,space   
  22.         ///<summary>  
  23.         ///停止位  
  24.         ///</summary>  
  25.         public byte StopBits = 0;   //0,1,2 = 1, 1.5, 2   
  26.         ///<summary>  
  27.         ///超时长  
  28.         ///</summary>  
  29.         public int ReadTimeout = 200;  
  30.         ///<summary>  
  31.         ///串口是否已经打开  
  32.         ///</summary>  
  33.         public bool Opened = false;  
  34.         ///<summary>  
  35.         /// COM口句柄  
  36.         ///</summary>  
  37.         private int hComm = -1;  
  38.    
  39.         #region "API相关定义"  
  40.         private const string DLLPATH = "\\windows\\coredll.dll"// "kernel32";  
  41.    
  42.         ///<summary>  
  43.         /// WINAPI常量,写标志  
  44.         ///</summary>  
  45.         private const uint GENERIC_READ = 0x80000000;  
  46.         ///<summary>  
  47.         /// WINAPI常量,读标志  
  48.         ///</summary>  
  49.         private const uint GENERIC_WRITE = 0x40000000;  
  50.         ///<summary>  
  51.         /// WINAPI常量,打开已存在  
  52.         ///</summary>  
  53.         private const int OPEN_EXISTING = 3;  
  54.         ///<summary>  
  55.         /// WINAPI常量,无效句柄  
  56.         ///</summary>  
  57.         private const int INVALID_HANDLE_VALUE = -1;  
  58.    
  59.         private const int PURGE_RXABORT = 0x2;  
  60.         private const int PURGE_RXCLEAR = 0x8;  
  61.         private const int PURGE_TXABORT = 0x1;  
  62.         private const int PURGE_TXCLEAR = 0x4;  
  63.    
  64.         ///<summary>  
  65.         ///设备控制块结构体类型  
  66.         ///</summary>  
  67.         [StructLayout(LayoutKind.Sequential)]  
  68.         public struct DCB  
  69.         {  
  70.            ///<summary>  
  71.             /// DCB长度  
  72.             ///</summary>  
  73.             public int DCBlength;  
  74.             ///<summary>  
  75.             ///指定当前波特率  
  76.             ///</summary>  
  77.             public int BaudRate;  
  78.             ///<summary>  
  79.             ///标志位  
  80.             ///</summary>  
  81.             public uint flags;  
  82.             ///<summary>  
  83.             ///未使用,必须为0  
  84.             ///</summary>  
  85.             public ushort wReserved;  
  86.             ///<summary>  
  87.             ///指定在XON字符发送这前接收缓冲区中可允许的最小字节数  
  88.             ///</summary>  
  89.             public ushort XonLim;  
  90.             ///<summary>  
  91.             ///指定在XOFF字符发送这前接收缓冲区中可允许的最小字节数  
  92.             ///</summary>  
  93.             public ushort XoffLim;  
  94.             ///<summary>  
  95.             ///指定端口当前使用的数据位  
  96.             ///</summary>  
  97.             public byte ByteSize;  
  98.             ///<summary>  
  99.             ///指定端口当前使用的奇偶校验方法,可能为:EVENPARITY,MARKPARITY,NOPARITY,ODDPARITY 0-4=no,odd,even,mark,space   
  100.             ///</summary>  
  101.             public byte Parity;  
  102.             ///<summary>  
  103.             ///指定端口当前使用的停止位数,可能为:ONESTOPBIT,ONE5STOPBITS,TWOSTOPBITS 0,1,2 = 1, 1.5, 2   
  104.             ///</summary>  
  105.             public byte StopBits;  
  106.             ///<summary>  
  107.             ///指定用于发送和接收字符XON的值 Tx and Rx XON character   
  108.             ///</summary>  
  109.             public byte XonChar;  
  110.             ///<summary>  
  111.             ///指定用于发送和接收字符XOFF值 Tx and Rx XOFF character   
  112.             ///</summary>  
  113.             public byte XoffChar;  
  114.             ///<summary>  
  115.             ///本字符用来代替接收到的奇偶校验发生错误时的值  
  116.             ///</summary>  
  117.             public byte ErrorChar;  
  118.             ///<summary>  
  119.             ///当没有使用二进制模式时,本字符可用来指示数据的结束  
  120.             ///</summary>  
  121.             public byte EofChar;  
  122.             ///<summary>  
  123.             ///当接收到此字符时,会产生一个事件  
  124.             ///</summary>  
  125.             public byte EvtChar;  
  126.             ///<summary>  
  127.             ///未使用  
  128.             ///</summary>  
  129.             public ushort wReserved1;  
  130.         }  
  131.    
  132.         ///<summary>  
  133.         ///串口超时时间结构体类型  
  134.         ///</summary>  
  135.         [StructLayout(LayoutKind.Sequential)]  
  136.         private struct COMMTIMEOUTS  
  137.         {  
  138.             public int ReadIntervalTimeout;  
  139.             public int ReadTotalTimeoutMultiplier;  
  140.             public int ReadTotalTimeoutConstant;  
  141.             public int WriteTotalTimeoutMultiplier;  
  142.             public int WriteTotalTimeoutConstant;  
  143.         }  
  144.    
  145.         ///<summary>  
  146.         ///溢出缓冲区结构体类型  
  147.         ///</summary>  
  148.         [StructLayout(LayoutKind.Sequential)]  
  149.         private struct OVERLAPPED  
  150.         {  
  151.             public int Internal;  
  152.             public int InternalHigh;  
  153.             public int Offset;  
  154.             public int OffsetHigh;  
  155.             public int hEvent;  
  156.         }  
  157.    
  158.         ///<summary>  
  159.         ///打开串口  
  160.         ///</summary>  
  161.         ///<param name="lpFileName">要打开的串口名称</param>  
  162.         ///<param name="dwDesiredAccess">指定串口的访问方式,一般设置为可读可写方式</param>  
  163.         ///<param name="dwShareMode">指定串口的共享模式,串口不能共享,所以设置为0</param>  
  164.         ///<param name="lpSecurityAttributes">设置串口的安全属性,WIN9X下不支持,应设为NULL</param>  
  165.         ///<param name="dwCreationDisposition">对于串口通信,创建方式只能为OPEN_EXISTING</param>  
  166.         ///<param name="dwFlagsAndAttributes">指定串口属性与标志,设置为FILE_FLAG_OVERLAPPED(重叠I/O操作),指定串口以异步方式通信</param>  
  167.         ///<param name="hTemplateFile">对于串口通信必须设置为NULL</param>  
  168.         [DllImport(DLLPATH)]  
  169.         private static extern int CreateFile(string lpFileName, uint dwDesiredAccess, int dwShareMode,  
  170.         int lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile);  
  171.    
  172.         ///<summary>  
  173.         ///得到串口状态  
  174.         ///</summary>  
  175.         ///<param name="hFile">通信设备句柄</param>  
  176.         ///<param name="lpDCB">设备控制块DCB</param>  
  177.         [DllImport(DLLPATH)]  
  178.         private static extern bool GetCommState(int hFile, ref DCB lpDCB);  
  179.    
  180.         ///<summary>  
  181.         ///建立串口设备控制块(嵌入版没有)  
  182.         ///</summary>  
  183.         ///<param name="lpDef">设备控制字符串</param>  
  184.         ///<param name="lpDCB">设备控制块</param>  
  185.         //[DllImport(DLLPATH)]  
  186.         //private static extern bool BuildCommDCB(string lpDef, ref DCB lpDCB);  
  187.    
  188.         ///<summary>  
  189.         ///设置串口状态  
  190.         ///</summary>  
  191.         ///<param name="hFile">通信设备句柄</param>  
  192.         ///<param name="lpDCB">设备控制块</param>  
  193.         [DllImport(DLLPATH)]  
  194.         private static extern bool SetCommState(int hFile, ref DCB lpDCB);  
  195.    
  196.         ///<summary>  
  197.         ///读取串口超时时间  
  198.         ///</summary>  
  199.         ///<param name="hFile">通信设备句柄</param>  
  200.         ///<param name="lpCommTimeouts">超时时间</param>  
  201.         [DllImport(DLLPATH)]  
  202.         private static extern bool GetCommTimeouts(int hFile, ref COMMTIMEOUTS lpCommTimeouts);  
  203.    
  204.         ///<summary>  
  205.         ///设置串口超时时间  
  206.         ///</summary>  
  207.         ///<param name="hFile">通信设备句柄</param>  
  208.         ///<param name="lpCommTimeouts">超时时间</param>  
  209.         [DllImport(DLLPATH)]  
  210.         private static extern bool SetCommTimeouts(int hFile, ref COMMTIMEOUTS lpCommTimeouts);  
  211.    
  212.         ///<summary>  
  213.         ///读取串口数据  
  214.         ///</summary>  
  215.         ///<param name="hFile">通信设备句柄</param>  
  216.         ///<param name="lpBuffer">数据缓冲区</param>  
  217.         ///<param name="nNumberOfBytesToRead">多少字节等待读取</param>  
  218.         ///<param name="lpNumberOfBytesRead">读取多少字节</param>  
  219.         ///<param name="lpOverlapped">溢出缓冲区</param>  
  220.         [DllImport(DLLPATH)]  
  221.         private static extern bool ReadFile(int hFile, byte[] lpBuffer, int nNumberOfBytesToRead,  
  222.         ref int lpNumberOfBytesRead, ref OVERLAPPED lpOverlapped);  
  223.    
  224.         ///<summary>  
  225.         ///写串口数据  
  226.         ///</summary>  
  227.         ///<param name="hFile">通信设备句柄</param>  
  228.         ///<param name="lpBuffer">数据缓冲区</param>  
  229.         ///<param name="nNumberOfBytesToWrite">多少字节等待写入</param>  
  230.         ///<param name="lpNumberOfBytesWritten">已经写入多少字节</param>  
  231.         ///<param name="lpOverlapped">溢出缓冲区</param>  
  232.         [DllImport(DLLPATH)]  
  233.         private static extern bool WriteFile(int hFile, byte[] lpBuffer, int nNumberOfBytesToWrite,  
  234.         ref int lpNumberOfBytesWritten, ref OVERLAPPED lpOverlapped);  
  235.    
  236.         [DllImport(DLLPATH, SetLastError = true)]  
  237.         private static extern bool FlushFileBuffers(int hFile);  
  238.    
  239.         [DllImport(DLLPATH, SetLastError = true)]  
  240.         private static extern bool PurgeComm(int hFile, uint dwFlags);  
  241.    
  242.         ///<summary>  
  243.         ///关闭串口  
  244.         ///</summary>  
  245.         ///<param name="hObject">通信设备句柄</param>  
  246.         [DllImport(DLLPATH)]  
  247.         private static extern bool CloseHandle(int hObject);  
  248.    
  249.         ///<summary>  
  250.         ///得到串口最后一次返回的错误  
  251.         ///</summary>  
  252.         [DllImport(DLLPATH)]  
  253.         private static extern uint GetLastError();  
  254.         #endregion  
  255.    
  256.         ///<summary>  
  257.         ///设置DCB标志位  
  258.         ///</summary>  
  259.         ///<param name="whichFlag"></param>  
  260.         ///<param name="setting"></param>  
  261.         ///<param name="dcb"></param>  
  262.         internal void SetDcbFlag(int whichFlag, int setting, DCB dcb)  
  263.         {  
  264.             uint num;  
  265.             setting = setting << whichFlag;  
  266.             if ((whichFlag == 4) || (whichFlag == 12))  
  267.             {  
  268.                 num = 3;  
  269.             }  
  270.             else if (whichFlag == 15)  
  271.             {  
  272.                 num = 0x1ffff;  
  273.             }  
  274.             else 
  275.             {  
  276.                 num = 1;  
  277.             }  
  278.             dcb.flags &= ~(num << whichFlag);  
  279.             dcb.flags |= (uint)setting;  
  280.         }  
  281.    
  282.         ///<summary>  
  283.         ///建立与串口的连接  
  284.         ///</summary>  
  285.         public int Open()  
  286.         {  
  287.             DCB dcb = new DCB();  
  288.             COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS();  
  289.    
  290.             // 打开串口   
  291.             hComm = CreateFile(Port, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);  
  292.             if (hComm == INVALID_HANDLE_VALUE)  
  293.             {  
  294.                 return -1;  
  295.             }  
  296.             // 设置通信超时时间  
  297.             GetCommTimeouts(hComm, ref ctoCommPort);  
  298.             ctoCommPort.ReadTotalTimeoutConstant = ReadTimeout;  
  299.             ctoCommPort.ReadTotalTimeoutMultiplier = 0;  
  300.             ctoCommPort.WriteTotalTimeoutMultiplier = 0;  
  301.             ctoCommPort.WriteTotalTimeoutConstant = 0;  
  302.             SetCommTimeouts(hComm, ref ctoCommPort);  
  303.    
  304.             //设置串口参数  
  305.             GetCommState(hComm, ref dcb);  
  306.             dcb.DCBlength = Marshal.SizeOf(dcb);  
  307.             dcb.BaudRate = BaudRate;  
  308.             dcb.flags = 0;  
  309.             dcb.ByteSize = (byte)ByteSize;  
  310.             dcb.StopBits = StopBits;  
  311.             dcb.Parity = (byte)Parity;  
  312.    
  313.             //------------------------------  
  314.             SetDcbFlag(0, 1, dcb);            //二进制方式   
  315.             SetDcbFlag(1, (Parity == 0) ? 0 : 1, dcb);  
  316.             SetDcbFlag(2, 0, dcb);            //不用CTS检测发送流控制  
  317.             SetDcbFlag(3, 0, dcb);            //不用DSR检测发送流控制  
  318.             SetDcbFlag(4, 0, dcb);            //禁止DTR流量控制  
  319.             SetDcbFlag(6, 0, dcb);            //对DTR信号线不敏感  
  320.             SetDcbFlag(9, 1, dcb);            //检测接收缓冲区  
  321.             SetDcbFlag(8, 0, dcb);            //不做发送字符控制  
  322.             SetDcbFlag(10, 0, dcb);           //是否用指定字符替换校验错的字符  
  323.             SetDcbFlag(11, 0, dcb);           //保留NULL字符  
  324.             SetDcbFlag(12, 0, dcb);           //允许RTS流量控制  
  325.             SetDcbFlag(14, 0, dcb);           //发送错误后,继续进行下面的读写操作  
  326.             //--------------------------------  
  327.             dcb.wReserved = 0;                       //没有使用,必须为0         
  328.             dcb.XonLim = 0;                          //指定在XOFF字符发送之前接收到缓冲区中可允许的最小字节数  
  329.             dcb.XoffLim = 0;                         //指定在XOFF字符发送之前缓冲区中可允许的最小可用字节数  
  330.             dcb.XonChar = 0;                         //发送和接收的XON字符   
  331.             dcb.XoffChar = 0;                        //发送和接收的XOFF字符  
  332.             dcb.ErrorChar = 0;                       //代替接收到奇偶校验错误的字符   
  333.             dcb.EofChar = 0;                         //用来表示数据的结束        
  334.             dcb.EvtChar = 0;                         //事件字符,接收到此字符时,会产生一个事件          
  335.             dcb.wReserved1 = 0;                      //没有使用   
  336.    
  337.             if (!SetCommState(hComm, ref dcb))  
  338.             {  
  339.                 return -2;  
  340.             }  
  341.             Opened = true;  
  342.             return 0;  
  343.         }  
  344.         ///<summary>  
  345.         ///关闭串口,结束通讯  
  346.         ///</summary>  
  347.         public void Close()  
  348.         {  
  349.             if (hComm != INVALID_HANDLE_VALUE)  
  350.             {  
  351.                 CloseHandle(hComm);  
  352.             }  
  353.         }  
  354.         ///<summary>  
  355.         ///读取串口返回的数据  
  356.         ///</summary>  
  357.         ///<param name="NumBytes">数据长度</param>  
  358.         public int Read(ref byte[] bytData, int NumBytes)  
  359.         {  
  360.             if (hComm != INVALID_HANDLE_VALUE)  
  361.             {  
  362.                 OVERLAPPED ovlCommPort = new OVERLAPPED();  
  363.                 int BytesRead = 0;  
  364.                 ReadFile(hComm, bytData, NumBytes, ref BytesRead, ref ovlCommPort);  
  365.                 return BytesRead;  
  366.             }  
  367.             else 
  368.             {  
  369.                 return -1;  
  370.             }  
  371.         }  
  372.    
  373.         ///<summary>  
  374.         ///向串口写数据  
  375.         ///</summary>  
  376.         ///<param name="WriteBytes">数据数组</param>  
  377.         public int Write(byte[] WriteBytes, int intSize)  
  378.         {  
  379.             if (hComm != INVALID_HANDLE_VALUE)  
  380.             {  
  381.                 OVERLAPPED ovlCommPort = new OVERLAPPED();  
  382.                 int BytesWritten = 0;  
  383.                 WriteFile(hComm, WriteBytes, intSize, ref BytesWritten, ref ovlCommPort);  
  384.                 return BytesWritten;  
  385.             }  
  386.             else 
  387.             {  
  388.                 return -1;  
  389.             }  
  390.         }  
  391.    
  392.         ///<summary>  
  393.         ///清除接收缓冲区  
  394.         ///</summary>  
  395.         ///<returns></returns>  
  396.         public void ClearReceiveBuf()  
  397.         {  
  398.             if (hComm != INVALID_HANDLE_VALUE)  
  399.             {  
  400.                 PurgeComm(hComm, PURGE_RXABORT | PURGE_RXCLEAR);  
  401.             }  
  402.         }  
  403.    
  404.         ///<summary>  
  405.         ///清除发送缓冲区  
  406.         ///</summary>  
  407.         public void ClearSendBuf()  
  408.         {  
  409.             if (hComm != INVALID_HANDLE_VALUE)  
  410.             {  
  411.                 PurgeComm(hComm, PURGE_TXABORT | PURGE_TXCLEAR);  
  412.             }  
  413.         }  
  414.  }  

后记:我的串口程序修改为API方式后,实际发现与SerialPort类遇到同样的问题,所以SerialPort类还是值得信任的。该API方式的代码在WinCE平台和PC平台都调试通过。


 















本文转自yefanqiu51CTO博客,原文链接:http://blog.51cto.com/yfsoft/323424,如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章
最新文章
相关文章