本文主要三大块：一，串口同步和异步在底层通信上的区别（这部分点到为止，不是主要探讨内容，有个基本理解即可）。
 
                             二，串口同步和异步编程实例及详解（主要部分）。
 
                             三，串口同步和异步的作用（着眼当下，理解为什么一定要区分串口的同步和异步，其作用到底有什么不同）。
 
 
 
一：异步通信和同步通信
  
 
串行通信进行数据传送时是将要传送的数据按二进制位，依据一定的顺序逐位发送到接收方。其有两种通信方式：
 
 
 
1、 异步通信
 
 
 
异步通信是我们最常采用的通信方式，我们后面的例子都是采用的异步通信方式。异步通信采用固定的通信格式，数据以相同的帧格式传送。如图7-3所示，每一帧由起始位、数据位、奇偶校验位和停止位组成。
 
 
 
 
 
 
 
 
在通信线上没有数据传送时处于逻辑“1”状态。当发送设备发送一个字符数据时，首先发出一个逻辑“0”信号，这个逻辑低电平就是起始位。起始位通过通信线传向接收设备，当接收设备检测到这个逻辑低电平后，就开始准备接收数据信号。因此，起始位所起的作用就是表示字符传送开始。
 
 
 
起始位后面紧接着的是数据位，它可以是5位、6位、7位、或8位。数据传送时，低位在前。
 
 
 
奇偶校验位用于数据传送过程中的数据检错，数据通信时通信双方必须约定一致的奇偶校验方式。就数据传送而言，奇偶校验位是冗余位，但它表示数据的一种性质。也有的不要校验位。
 
 
 
在奇偶校验位或数据位后紧接的是停止位，停止位可以是一位、也可以是1.5位或2位。接收端收到停止位后，知道上一字符已传送完毕，同时，也为接收下一字符作好准备。若停止位后不是紧接着传送下一个字符，则让线路保持为“1”。“1”表示空闲位，线路处于等待状态。存在空闲位是异步通信的特性之一。
 
 
 
2、 同步通信
 
 
 
同步通信时，通信双方共用一个时钟，这是同步通信区分于异步通信的最显著的特点。在异步通信中，每个字符要用起始位和停止位作为字符开始和结束的标志，以致占用了时间。所以在数据块传送时，为提高通信速度，常去掉这些标志，而采用同步通信。同步通信中，数据开始传送前用同步字符来指示（常约定1～2个），并由时钟来实现发送端和接收端的同步，即检测到规定的同步字符后，下面就连续按顺序传送数据，直到一块数据传送完毕。同步传送时，字符之间没有间隙，也不要起始位和停止位，仅在数据开始时用同步字符SYNC来指示，其数据格式见图7-4。
 
 
 
 
 
 
 
 
 
 
 
 
同步通信和异步通信相比有以下特点：
 
 
 
1.以同步字符作为传送的开始，从而使收发双方取得同步。
 
 
 
2.每位占用的时间相等。
 
 
 
3.字符数据之间不允许有空位，当线路空闲或没字符可发时，发送同步字符。
 
同步字符的插入可以是单同步字符或双同步字符，如图7-4所示同步字符也可以由用户约定，当然也可以采用ASCII码中规定的SYN代码，即16H。
 
在同步传送时，要求用时钟来实现发送端和接收端之间的同步。为了保证接收正确无误，发送方除了传送数据外，还要传送同步时钟。
 
同步通信虽然可以提高传送速度，可达56Kb/s或更高，但实现起来颇为复杂，因此实际较少使用。
 
 
 
 波特率和接收发送时钟
 
 
 
1． 波特率（Baud rate）
 
 
 
波特率是指数据传送时，每秒传送数据二进制代码的位数，它的单位是位/秒（b/s）。1波特就是一位每秒。假设数据传送速率是每秒120字符，而每个字符格式包括10个代码位（1个起始位、一个终止位、8个数据位），这时传送的波特率为：
 
 
 
10× 120 = 1200b/s
 
 
 
位传送时间宽度Td＝波特率的倒数，则上式中的Td＝1/1200s＝0.883ms。
 
 
 
在异步串行通信中，接收设备和发送设备保持相同的传送波特率，并以每个字符数据的起始位与发送设备保持同步。起始位。数据位。奇偶位和停止位的约定，在同一次传送过程中必须保持一致，这样才能成功的传送数据。
 
 
 
2.接收/发送时钟
 
 
 
二进制数据系列在串行传送过程中以数字信号波形的形式出现。不论接收还是发送，都必须有时钟信号对传送的数据进行定位。接收/发送时钟就是用来控制通信设备接收/发送字符数据速度的，该时钟信号通常由外部时钟电路产生。
 
 
 
在发送数据时，发送器在发送时钟的下降沿将移位寄存器的数据串行移位输出；在接收数据时，接收器在接收时钟的上升沿对接收数据采样，进行数据位检测，
 
如图7-5所示。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
接收/发送时钟频率与波特率有如下关系：
 
 
 
收/发时钟频率 ＝ n × 收/发波特率
 
n＝1，16，64
 
 
 
在同步传送方式，必须取n＝1，即接收/发送时钟的频率等于收/发波特率。在异步传送方式，n＝1,16,64,即可以选择接收/发送时钟频率是波特率的1,16,64倍。因此可由要求的传送波特率及所选择的倍数n来确定接收/发送时钟的频率。
 
 
 
例如，若要求数据传送的波特率为300Baud，则
 
接收/发送时钟频率＝300Hz（n＝1）
 
接收/发送时钟频率＝4800Hz（n＝16）
 
接收/发送时钟频率＝19.2kHz（n＝64）
 
 
 
接收/发送时钟的周期Tc与传送的数据位宽之间的关系是：
 
 
 
Tc＝ Td / n
 
 
 
若取n＝16,那么异步传送接收数据实现同步的过程如下：接收器在每一个接收时钟的上升沿采样接收数据线，当发现接收数据线出现低电平时就认为是起始位的开始，以后若在连续撤8个时钟周期（因n＝16,故Td＝16Tc）内检测到接收数据线仍保持低电平，则确定它为起始位（不是干扰信号）。通过这种方法，不仅能够排除接收线上的噪声干扰，识别假起始位，而且能够相当精确的确定起始位的中间点，从而提供一个正确的时间基准。从这个基准算起，每隔16Tc采样一次数据线，作为输入数据。一般来说，从接收数据线检测到一个下降沿开始，若其低电平能保持n/2Tc（半位时间），则确定为起始位，其后每隔nTc时间（一个数据时间）在每个数据位的中间点采样。
 
 
 
由此可见，接收/发送时钟对于收/发双方之间的数据传输达到同步是至关重要的
 
 
 
 
 
二：win32 串口同步和异步编程
 
 
 
在工业控制中，工控机（一般都基于Windows平台）经常需要与智能仪表通过串口进行通信。串口通信方便易行，应用广泛。
 一般情况下，工控机和各智能仪表通过RS485总线进行通信。RS485的通信方式是半双工的，只能由作为主节点的工控PC机依次轮询网络上的各智能控制单元子节点。每次通信都是由PC机通过串口向智能控制单元发布命令，智能控制单元在接收到正确的命令后作出应答。
 　　在Win32下，可以使用两种编程方式实现串口通信，其一是使用ActiveX控件，这种方法程序简单，但欠灵活。其二是调用Windows的API函数，这种方法可以清楚地掌握串口通信的机制，并且自由灵活。本文我们只介绍API串口通信部分。
 　　串口的操作可以有两种操作方式：同步操作方式和重叠操作方式（又称为异步操作方式）。同步操作时，API函数会阻塞直到操作完成以后才能返回（在多线程方式中，虽然不会阻塞主线程，但是仍然会阻塞监听线程）；而重叠操作方式，API函数会立即返回，操作在后台进行，避免线程的阻塞。
 
无论那种操作方式，一般都通过四个步骤来完成：
 （1） 打开串口
 （2） 配置串口
 （3） 读写串口
 （4） 关闭串口
 
（1） 打开串口
 
　　Win32系统把文件的概念进行了扩展。无论是文件、通信设备、命名管道、邮件槽、磁盘、还是控制台，都是用API函数CreateFile来打开或创建的。该函数的原型为：
 
HANDLE CreateFile( LPCTSTR lpFileName,
                   DWORD dwDesiredAccess,
                   DWORD dwShareMode,
                   LPSECURITY_ATTRIBUTES lpSecurityAttributes,
                   DWORD dwCreationDistribution,
 DWORD dwFlagsAndAttributes,
 HANDLE hTemplateFile);
 
lpFileName：将要打开的串口逻辑名，如“COM1”；
 dwDesiredAccess：指定串口访问的类型，可以是读取、写入或二者并列；
 dwShareMode：指定共享属性，由于串口不能共享，该参数必须置为0；
 lpSecurityAttributes：引用安全性属性结构，缺省值为NULL；
 dwCreationDistribution：创建标志，对串口操作该参数必须置为OPEN_EXISTING；
 dwFlagsAndAttributes：属性描述，用于指定该串口是否进行异步操作，该值为FILE_FLAG_OVERLAPPED，表示使用异步的I/O；该值为0，表示同步I/O操作；
 hTemplateFile：对串口而言该参数必须置为NULL；
 同步I/O方式打开串口的示例代码：
 
 HANDLE hCom;  //全局变量，串口句柄
  hCom=CreateFile("COM1",//COM1口
   GENERIC_READ|GENERIC_WRITE, //允许读和写
   0, //独占方式
   NULL,
   OPEN_EXISTING, //打开而不是创建
   0, //同步方式
   NULL);
  if(hCom==(HANDLE)-1)
  {
   AfxMessageBox("打开COM失败!");
   return FALSE;
  }
  return TRUE;
 

 重叠I/O打开串口的示例代码：  HANDLE hCom;  //全局变量，串口句柄
  hCom =CreateFile("COM1",  //COM1口
              GENERIC_READ|GENERIC_WRITE, //允许读和写
              0,  //独占方式
              NULL,
              OPEN_EXISTING,  //打开而不是创建
              FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式
              NULL);
  if(hCom ==INVALID_HANDLE_VALUE)
  {
   AfxMessageBox("打开COM失败!");
   return FALSE;
  }
     return TRUE;
 
（2）、配置串口
 　　在打开通讯设备句柄后，常常需要对串口进行一些初始化配置工作。这需要通过一个DCB结构来进行。DCB结构包含了诸如波特率、数据位数、奇偶校验和停止位数等信息。在查询或配置串口的属性时，都要用DCB结构来作为缓冲区。
 　　一般用CreateFile打开串口后，可以调用GetCommState函数来获取串口的初始配置。要修改串口的配置，应该先修改DCB结构，然后再调用SetCommState函数设置串口。
 　　DCB结构包含了串口的各项参数设置，下面仅介绍几个该结构常用的变量：
 
typedef struct _DCB{
    ………
    //波特率，指定通信设备的传输速率。这个成员可以是实际波特率值或者下面的常量值之一：
    DWORD BaudRate;
 CBR_110，CBR_300，CBR_600，CBR_1200，CBR_2400，CBR_4800，CBR_9600，CBR_19200， CBR_38400，
 CBR_56000， CBR_57600， CBR_115200， CBR_128000， CBR_256000， CBR_14400
 
DWORD fParity; // 指定奇偶校验使能。若此成员为1，允许奇偶校验检查
    …
 BYTE ByteSize; // 通信字节位数，4—8
 BYTE Parity; //指定奇偶校验方法。此成员可以有下列值：
 EVENPARITY 偶校验     NOPARITY 无校验
 MARKPARITY 标记校验   ODDPARITY 奇校验
 BYTE StopBits; //指定停止位的位数。此成员可以有下列值：
 ONESTOPBIT 1位停止位   TWOSTOPBITS 2位停止位
 ONE5STOPBITS   1.5位停止位
    ………
   } DCB;
 winbase.h文件中定义了以上用到的常量。如下：
 #define NOPARITY            0
 #define ODDPARITY           1
 #define EVENPARITY          2
 #define ONESTOPBIT          0
 #define ONE5STOPBITS        1
 #define TWOSTOPBITS         2
 #define CBR_110             110
 #define CBR_300             300
 #define CBR_600             600
 #define CBR_1200            1200
 #define CBR_2400            2400
 #define CBR_4800            4800
 #define CBR_9600            9600
 #define CBR_14400           14400
 #define CBR_19200           19200
 #define CBR_38400           38400
 #define CBR_56000           56000
 #define CBR_57600           57600
 #define CBR_115200          115200
 #define CBR_128000          128000
 #define CBR_256000          256000
 
GetCommState函数可以获得COM口的设备控制块，从而获得相关参数： BOOL GetCommState(
    HANDLE hFile, //标识通讯端口的句柄
    LPDCB lpDCB //指向一个设备控制块（DCB结构）的指针
   );
 SetCommState函数设置COM口的设备控制块：
 BOOL SetCommState(
    HANDLE hFile,
    LPDCB lpDCB
   );
 
　　除了在BCD中的设置外，程序一般还需要设置I/O缓冲区的大小和超时。Windows用I/O缓冲区来暂存串口输入和输出的数据。如果通信的速率较高，则应该设置较大的缓冲区。调用SetupComm函数可以设置串行口的输入和输出缓冲区的大小。 BOOL SetupComm(
 
    HANDLE hFile, // 通信设备的句柄
     DWORD dwInQueue, // 输入缓冲区的大小（字节数）
     DWORD dwOutQueue // 输出缓冲区的大小（字节数）
    );
 
　　在用ReadFile和WriteFile读写串行口时，需要考虑超时问题。超时的作用是在指定的时间内没有读入或发送指定数量的字符，ReadFile或WriteFile的操作仍然会结束。
 　　要查询当前的超时设置应调用GetCommTimeouts函数，该函数会填充一个COMMTIMEOUTS结构。调用SetCommTimeouts可以用某一个COMMTIMEOUTS结构的内容来设置超时。
 　　读写串口的超时有两种：间隔超时和总超时。间隔超时是指在接收时两个字符之间的最大时延。总超时是指读写操作总共花费的最大时间。写操作只支持总超时，而读操作两种超时均支持。用COMMTIMEOUTS结构可以规定读写操作的超时。
 COMMTIMEOUTS结构的定义为： typedef struct _COMMTIMEOUTS {  
     DWORD ReadIntervalTimeout; //读间隔超时
     DWORD ReadTotalTimeoutMultiplier; //读时间系数
     DWORD ReadTotalTimeoutConstant; //读时间常量
     DWORD WriteTotalTimeoutMultiplier; // 写时间系数
     DWORD WriteTotalTimeoutConstant; //写时间常量
 } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
 
COMMTIMEOUTS结构的成员都以毫秒为单位。总超时的计算公式是：
 总超时＝时间系数×要求读/写的字符数＋时间常量
 例如，要读入10个字符，那么读操作的总超时的计算公式为：
 读总超时＝ReadTotalTimeoutMultiplier×10＋ReadTotalTimeoutConstant
 可以看出：间隔超时和总超时的设置是不相关的，这可以方便通信程序灵活地设置各种超时。
 
如果所有写超时参数均为0，那么就不使用写超时。如果ReadIntervalTimeout为0，那么就不使用读间隔超时。如果ReadTotalTimeoutMultiplier 和 ReadTotalTimeoutConstant 都为0，则不使用读总超时。如果读间隔超时被设置成MAXDWORD并且读时间系数和读时间常量都为0，那么在读一次输入缓冲区的内容后读操作就立即返回，而不管是否读入了要求的字符。
 　　在用重叠方式读写串口时，虽然ReadFile和WriteFile在完成操作以前就可能返回，但超时仍然是起作用的。在这种情况下，超时规定的是操作的完成时间，而不是ReadFile和WriteFile的返回时间。
 配置串口的示例代码：  SetupComm(hCom,1024,1024); //输入缓冲区和输出缓冲区的大小都是1024
 
 COMMTIMEOUTS TimeOuts;
  //设定读超时
  TimeOuts.ReadIntervalTimeout=1000;
  TimeOuts.ReadTotalTimeoutMultiplier=500;
  TimeOuts.ReadTotalTimeoutConstant=5000;
  //设定写超时
  TimeOuts.WriteTotalTimeoutMultiplier=500;
  TimeOuts.WriteTotalTimeoutConstant=2000;
  SetCommTimeouts(hCom,&TimeOuts); //设置超时
 
 DCB dcb;
  GetCommState(hCom,&dcb);
  dcb.BaudRate=9600; //波特率为9600
  dcb.ByteSize=8; //每个字节有8位
  dcb.Parity=NOPARITY; //无奇偶校验位
  dcb.StopBits=TWOSTOPBITS; //两个停止位
  SetCommState(hCom,&dcb);
 
 PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);
 
在读写串口之前，还要用PurgeComm()函数清空缓冲区，该函数原型： BOOL PurgeComm(
 
    HANDLE hFile, //串口句柄
     DWORD dwFlags // 需要完成的操作
    ); 
 
参数dwFlags指定要完成的操作，可以是下列值的组合： PURGE_TXABORT   中断所有写操作并立即返回，即使写操作还没有完成。
 PURGE_RXABORT   中断所有读操作并立即返回，即使读操作还没有完成。
 PURGE_TXCLEAR   清除输出缓冲区
 PURGE_RXCLEAR   清除输入缓冲区
 
（3）、读写串口
 我们使用ReadFile和WriteFile读写串口，下面是两个函数的声明：
 
BOOL ReadFile(
 
    HANDLE hFile, //串口的句柄
    
     // 读入的数据存储的地址，
     // 即读入的数据将存储在以该指针的值为首地址的一片内存区
     LPVOID lpBuffer, 
     DWORD nNumberOfBytesToRead, // 要读入的数据的字节数
    
     // 指向一个DWORD数值，该数值返回读操作实际读入的字节数
     LPDWORD lpNumberOfBytesRead, 
    
     // 重叠操作时，该参数指向一个OVERLAPPED结构，同步操作时，该参数为NULL。
     LPOVERLAPPED lpOverlapped  
    ); 
 BOOL WriteFile(
 
    HANDLE hFile, //串口的句柄
    
     // 写入的数据存储的地址，
     // 即以该指针的值为首地址的nNumberOfBytesToWrite
     // 个字节的数据将要写入串口的发送数据缓冲区。
     LPCVOID lpBuffer, 
    
     DWORD nNumberOfBytesToWrite, //要写入的数据的字节数
    
     // 指向指向一个DWORD数值，该数值返回实际写入的字节数
     LPDWORD lpNumberOfBytesWritten, 
    
     // 重叠操作时，该参数指向一个OVERLAPPED结构，
     // 同步操作时，该参数为NULL。
     LPOVERLAPPED lpOverlapped  
    );
 
　　在用ReadFile和WriteFile读写串口时，既可以同步执行，也可以重叠执行。在同步执行时，函数直到操作完成后才返回。这意味着同步执行时线程会被阻塞，从而导致效率下降。在重叠执行时，即使操作还未完成，这两个函数也会立即返回，费时的I/O操作在后台进行。
 　　ReadFile和WriteFile函数是同步还是异步由CreateFile函数决定，如果在调用CreateFile创建句柄时指定了FILE_FLAG_OVERLAPPED标志，那么调用ReadFile和WriteFile对该句柄进行的操作就应该是重叠的；如果未指定重叠标志，则读写操作应该是同步的。ReadFile和WriteFile函数的同步或者异步应该和CreateFile函数相一致。
 　　ReadFile函数只要在串口输入缓冲区中读入指定数量的字符，就算完成操作。而WriteFile函数不但要把指定数量的字符拷入到输出缓冲区，而且要等这些字符从串行口送出去后才算完成操作。
 　　如果操作成功，这两个函数都返回TRUE。需要注意的是，当ReadFile和WriteFile返回FALSE时，不一定就是操作失败，线程应该调用GetLastError函数分析返回的结果。例如，在重叠操作时如果操作还未完成函数就返回，那么函数就返回FALSE，而且GetLastError函数返回ERROR_IO_PENDING。这说明重叠操作还未完成。
 
同步方式读写串口比较简单，下面先例举同步方式读写串口的代码： //同步读串口
 char str[100];
 DWORD wCount;//读取的字节数
 BOOL bReadStat;
 bReadStat=ReadFile(hCom,str,100,&wCount,NULL);
 if(!bReadStat)
 {
  AfxMessageBox("读串口失败!");
  return FALSE;
 }
 return TRUE;
 
//同步写串口
 
 char lpOutBuffer[100];
  DWORD dwBytesWrite=100;
  COMSTAT ComStat;
  DWORD dwErrorFlags;
  BOOL bWriteStat;
  ClearCommError(hCom,&dwErrorFlags,&ComStat);
  bWriteStat=WriteFile(hCom,lpOutBuffer,dwBytesWrite,& dwBytesWrite,NULL);
  if(!bWriteStat)
  {
   AfxMessageBox("写串口失败!");
  }
  PurgeComm(hCom, PURGE_TXABORT|
   PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
 
在重叠操作时,操作还未完成函数就返回。
 
　　重叠I/O非常灵活，它也可以实现阻塞（例如我们可以设置一定要读取到一个数据才能进行到下一步操作）。有两种方法可以等待操作完成：一种方法是用象WaitForSingleObject这样的等待函数来等待OVERLAPPED结构的hEvent成员；另一种方法是调用GetOverlappedResult函数等待，后面将演示说明。
 下面我们先简单说一下OVERLAPPED结构和GetOverlappedResult函数：
 OVERLAPPED结构
 OVERLAPPED结构包含了重叠I/O的一些信息，定义如下： typedef struct _OVERLAPPED { // o 
     DWORD  Internal;
     DWORD  InternalHigh;
     DWORD  Offset;
     DWORD  OffsetHigh;
     HANDLE hEvent;
 } OVERLAPPED;
 
　　在使用ReadFile和WriteFile重叠操作时，线程需要创建OVERLAPPED结构以供这两个函数使用。线程通过OVERLAPPED结构获得当前的操作状态，该结构最重要的成员是hEvent。hEvent是读写事件。当串口使用异步通讯时，函数返回时操作可能还没有完成，程序可以通过检查该事件得知是否读写完毕。
 　　当调用ReadFile, WriteFile 函数的时候，该成员会自动被置为无信号状态；当重叠操作完成后，该成员变量会自动被置为有信号状态。 GetOverlappedResult函数
 BOOL GetOverlappedResult(
     HANDLE hFile, // 串口的句柄 
    
     // 指向重叠操作开始时指定的OVERLAPPED结构
     LPOVERLAPPED lpOverlapped, 
    
     // 指向一个32位变量，该变量的值返回实际读写操作传输的字节数。
     LPDWORD lpNumberOfBytesTransferred, 
    
     // 该参数用于指定函数是否一直等到重叠操作结束。
     // 如果该参数为TRUE，函数直到操作结束才返回。
     // 如果该参数为FALSE，函数直接返回，这时如果操作没有完成，
     // 通过调用GetLastError()函数会返回ERROR_IO_INCOMPLETE。
     BOOL bWait  
    ); 
 
该函数返回重叠操作的结果，用来判断异步操作是否完成，它是通过判断OVERLAPPED结构中的hEvent是否被置位来实现的。
 
异步读串口的示例代码： char lpInBuffer[1024];
 DWORD dwBytesRead=1024;
 COMSTAT ComStat;
 DWORD dwErrorFlags;
 OVERLAPPED m_osRead;
 memset(&m_osRead,0,sizeof(OVERLAPPED));
 m_osRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
 
ClearCommError(hCom,&dwErrorFlags,&ComStat);
 dwBytesRead=min(dwBytesRead,(DWORD)ComStat.cbInQue);
 if(!dwBytesRead)
 return FALSE;
 BOOL bReadStatus;
 bReadStatus=ReadFile(hCom,lpInBuffer,
       dwBytesRead,&dwBytesRead,&m_osRead);
 
if(!bReadStatus) //如果ReadFile函数返回FALSE
 {
  if(GetLastError()==ERROR_IO_PENDING)
  //GetLastError()函数返回ERROR_IO_PENDING,表明串口正在进行读操作 
  {
   WaitForSingleObject(m_osRead.hEvent,2000);
   //使用WaitForSingleObject函数等待，直到读操作完成或延时已达到2秒钟
   //当串口读操作进行完毕后，m_osRead的hEvent事件会变为有信号
   PurgeComm(hCom, PURGE_TXABORT|
    PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
   return dwBytesRead;
  }
  return 0;
 }
 PurgeComm(hCom, PURGE_TXABORT|
     PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
 return dwBytesRead;
 
　　对以上代码再作简要说明：在使用ReadFile 函数进行读操作前，应先使用ClearCommError函数清除错误。ClearCommError函数的原型如下： BOOL ClearCommError(
 
    HANDLE hFile, // 串口句柄
     LPDWORD lpErrors, // 指向接收错误码的变量
     LPCOMSTAT lpStat // 指向通讯状态缓冲区
    ); 
 
该函数获得通信错误并报告串口的当前状态，同时，该函数清除串口的错误标志以便继续输入、输出操作。
 参数lpStat指向一个COMSTAT结构，该结构返回串口状态信息。 COMSTAT结构 COMSTAT结构包含串口的信息，结构定义如下： typedef struct _COMSTAT { // cst 
     DWORD fCtsHold : 1;   // Tx waiting for CTS signal
     DWORD fDsrHold : 1;   // Tx waiting for DSR signal
     DWORD fRlsdHold : 1;  // Tx waiting for RLSD signal
     DWORD fXoffHold : 1;  // Tx waiting, XOFF char rec''d
     DWORD fXoffSent : 1;  // Tx waiting, XOFF char sent
     DWORD fEof : 1;       // EOF character sent
     DWORD fTxim : 1;      // character waiting for Tx
     DWORD fReserved : 25; // reserved
     DWORD cbInQue;        // bytes in input buffer
     DWORD cbOutQue;       // bytes in output buffer
 } COMSTAT, *LPCOMSTAT;
 
本文只用到了cbInQue成员变量，该成员变量的值代表输入缓冲区的字节数。
 
　　最后用PurgeComm函数清空串口的输入输出缓冲区。
 　　这段代码用WaitForSingleObject函数来等待OVERLAPPED结构的hEvent成员，下面我们再演示一段调用GetOverlappedResult函数等待的异步读串口示例代码：
 
char lpInBuffer[1024];
 DWORD dwBytesRead=1024;
  BOOL bReadStatus;
  DWORD dwErrorFlags;
  COMSTAT ComStat;
 OVERLAPPED m_osRead;
 
 ClearCommError(hCom,&dwErrorFlags,&ComStat);
  if(!ComStat.cbInQue)
   return 0;
  dwBytesRead=min(dwBytesRead,(DWORD)ComStat.cbInQue);
  bReadStatus=ReadFile(hCom, lpInBuffer,dwBytesRead,
   &dwBytesRead,&m_osRead);
  if(!bReadStatus) //如果ReadFile函数返回FALSE
  {
   if(GetLastError()==ERROR_IO_PENDING)
   {
    GetOverlappedResult(hCom,
     &m_osRead,&dwBytesRead,TRUE);
            // GetOverlappedResult函数的最后一个参数设为TRUE，
            //函数会一直等待，直到读操作完成或由于错误而返回。
 
   return dwBytesRead;
   }
   return 0;
  }
  return dwBytesRead;
 
异步写串口的示例代码： char buffer[1024];
 DWORD dwBytesWritten=1024;
  DWORD dwErrorFlags;
  COMSTAT ComStat;
 OVERLAPPED m_osWrite;
  BOOL bWriteStat;
 
 bWriteStat=WriteFile(hCom,buffer,dwBytesWritten,
   &dwBytesWritten,&m_OsWrite);
  if(!bWriteStat)
  {
   if(GetLastError()==ERROR_IO_PENDING)
   {
    WaitForSingleObject(m_osWrite.hEvent,1000);
    return dwBytesWritten;
   }
   return 0;
  }
  return dwBytesWritten;
 
（4）、关闭串口
 　　利用API函数关闭串口非常简单，只需使用CreateFile函数返回的句柄作为参数调用CloseHandle即可：
 
BOOL CloseHandle(
     HANDLE hObject; //handle to object to close
 );
 
串口编程的一个实例
 　　为了让您更好地理解串口编程,下面我们分别编写两个例程（见附带的源码部分）,这两个例程都实现了工控机与百特显示仪表通过RS485接口进行的串口通信。其中第一个例程采用同步串口操作,第二个例程采用异步串口操作。
 　　我们只介绍软件部分，RS485接口接线方法不作介绍，感兴趣的读者可以查阅相关资料。
 
例程1
 
　　打开VC++6.0，新建基于对话框的工程RS485Comm，在主对话框窗口IDD_RS485COMM_DIALOG上添加两个按钮，ID分别为IDC_SEND和IDC_RECEIVE，标题分别为“发送”和“接收”；添加一个静态文本框IDC_DISP，用于显示串口接收到的内容。
 
在RS485CommDlg.cpp文件中添加全局变量：
 
HANDLE hCom;  //全局变量，串口句柄
 
在RS485CommDlg.cpp文件中的OnInitDialog()函数添加如下代码：  // TODO: Add extra initialization here
  hCom=CreateFile("COM1",//COM1口
   GENERIC_READ|GENERIC_WRITE, //允许读和写
   0, //独占方式
   NULL,
   OPEN_EXISTING, //打开而不是创建
   0, //同步方式
   NULL);
  if(hCom==(HANDLE)-1)
  {
   AfxMessageBox("打开COM失败!");
   return FALSE;
  }
 
 SetupComm(hCom,100,100); //输入缓冲区和输出缓冲区的大小都是1024
 
 COMMTIMEOUTS TimeOuts;
  //设定读超时
  TimeOuts.ReadIntervalTimeout=MAXDWORD;
  TimeOuts.ReadTotalTimeoutMultiplier=0;
  TimeOuts.ReadTotalTimeoutConstant=0;
  //在读一次输入缓冲区的内容后读操作就立即返回，
  //而不管是否读入了要求的字符。
 

  //设定写超时
  TimeOuts.WriteTotalTimeoutMultiplier=100;
  TimeOuts.WriteTotalTimeoutConstant=500;
  SetCommTimeouts(hCom,&TimeOuts); //设置超时
 
 DCB dcb;
  GetCommState(hCom,&dcb);
  dcb.BaudRate=9600; //波特率为9600
  dcb.ByteSize=8; //每个字节有8位
  dcb.Parity=NOPARITY; //无奇偶校验位
  dcb.StopBits=TWOSTOPBITS; //两个停止位
  SetCommState(hCom,&dcb);
 
 PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);
 
分别双击IDC_SEND按钮和IDC_RECEIVE按钮，添加两个按钮的响应函数： void CRS485CommDlg::OnSend()
 {
  // TODO: Add your control notification handler code here
  // 在此需要简单介绍百特公司XMA5000的通讯协议：
  //该仪表RS485通讯采用主机广播方式通讯。
  //串行半双工，帧11位，1个起始位(0)，8个数据位，2个停止位(1)
  //如：读仪表显示的瞬时值，主机发送：DC1 AAA BB ETX
  //其中：DC1是标准ASCII码的一个控制符号，码值为11H(十进制的17)
  //在XMA5000的通讯协议中，DC1表示读瞬时值
  //AAA是从机地址码，也就是XMA5000显示仪表的通讯地址
  //BB为通道号，读瞬时值时该值为01
  //ETX也是标准ASCII码的一个控制符号，码值为03H
  //在XMA5000的通讯协议中，ETX表示主机结束符
 
 char lpOutBuffer[7];
  memset(lpOutBuffer,''/0'',7); //前7个字节先清零
  lpOutBuffer[0]=''/x11'';  //发送缓冲区的第1个字节为DC1
  lpOutBuffer[1]=''0'';  //第2个字节为字符0(30H)
  lpOutBuffer[2]=''0''; //第3个字节为字符0(30H)
  lpOutBuffer[3]=''1''; // 第4个字节为字符1(31H)
  lpOutBuffer[4]=''0''; //第5个字节为字符0(30H)
  lpOutBuffer[5]=''1''; //第6个字节为字符1(31H)
  lpOutBuffer[6]=''/x03''; //第7个字节为字符ETX
  //从该段代码可以看出，仪表的通讯地址为001 
  DWORD dwBytesWrite=7;
  COMSTAT ComStat;
  DWORD dwErrorFlags;
  BOOL bWriteStat;
  ClearCommError(hCom,&dwErrorFlags,&ComStat);
  bWriteStat=WriteFile(hCom,lpOutBuffer,dwBytesWrite,& dwBytesWrite,NULL);
  if(!bWriteStat)
  {
   AfxMessageBox("写串口失败!");
  }
 
}
 void CRS485CommDlg::OnReceive()
 {
  // TODO: Add your control notification handler code here
 
 char str[100];
  memset(str,''/0'',100);
  DWORD wCount=100;//读取的字节数
  BOOL bReadStat;
  bReadStat=ReadFile(hCom,str,wCount,&wCount,NULL);
  if(!bReadStat)
   AfxMessageBox("读串口失败!");
  PurgeComm(hCom, PURGE_TXABORT|
   PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
  m_disp=str;
  UpdateData(FALSE);
  
 }
 
您可以观察返回的字符串，其中有和仪表显示值相同的部分，您可以进行相应的字符串操作取出仪表的显示值。
 打开ClassWizard,为静态文本框IDC_DISP添加CString类型变量m_disp，同时添加WM_CLOSE的相应函数： void CRS485CommDlg::OnClose()
 {
  // TODO: Add your message handler code here and/or call default
     CloseHandle(hCom); //程序退出时关闭串口
  CDialog::OnClose();
 }
 
程序的相应部分已经在代码内部作了详细介绍。连接好硬件部分，编译运行程序，细心体会串口同步操作部分。
 例程2
 
　　打开VC++6.0，新建基于对话框的工程RS485Comm，在主对话框窗口IDD_RS485COMM_DIALOG上添加两个按钮，ID分别为IDC_SEND和IDC_RECEIVE，标题分别为“发送”和“接收”；添加一个静态文本框IDC_DISP，用于显示串口接收到的内容。在RS485CommDlg.cpp文件中添加全局变量：
 
HANDLE hCom; //全局变量，
 串口句柄在RS485CommDlg.cpp文件中的OnInitDialog()函数添加如下代码：
 
 hCom=CreateFile("COM1",//COM1口
   GENERIC_READ|GENERIC_WRITE, //允许读和写
   0, //独占方式
   NULL,
   OPEN_EXISTING, //打开而不是创建
   FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式
   NULL);
  if(hCom==(HANDLE)-1)
  {
   AfxMessageBox("打开COM失败!");
   return FALSE;
  }
 
 SetupComm(hCom,100,100); //输入缓冲区和输出缓冲区的大小都是100
 
 COMMTIMEOUTS TimeOuts;
  //设定读超时
  TimeOuts.ReadIntervalTimeout=MAXDWORD;
  TimeOuts.ReadTotalTimeoutMultiplier=0;
  TimeOuts.ReadTotalTimeoutConstant=0;
  //在读一次输入缓冲区的内容后读操作就立即返回，
  //而不管是否读入了要求的字符。
 

  //设定写超时
  TimeOuts.WriteTotalTimeoutMultiplier=100;
  TimeOuts.WriteTotalTimeoutConstant=500;
  SetCommTimeouts(hCom,&TimeOuts); //设置超时
 
 DCB dcb;
  GetCommState(hCom,&dcb);
  dcb.BaudRate=9600; //波特率为9600
  dcb.ByteSize=8; //每个字节有8位
  dcb.Parity=NOPARITY; //无奇偶校验位
  dcb.StopBits=TWOSTOPBITS; //两个停止位
  SetCommState(hCom,&dcb);
 
 PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);
 
分别双击IDC_SEND按钮和IDC_RECEIVE按钮，添加两个按钮的响应函数： void CRS485CommDlg::OnSend()
 {
  // TODO: Add your control notification handler code here
  OVERLAPPED m_osWrite;
  memset(&m_osWrite,0,sizeof(OVERLAPPED));
  m_osWrite.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
 

  char lpOutBuffer[7];
  memset(lpOutBuffer,''/0'',7);
  lpOutBuffer[0]=''/x11'';
  lpOutBuffer[1]=''0'';
  lpOutBuffer[2]=''0'';
  lpOutBuffer[3]=''1'';
  lpOutBuffer[4]=''0'';
  lpOutBuffer[5]=''1'';
  lpOutBuffer[6]=''/x03'';
  
  DWORD dwBytesWrite=7;
  COMSTAT ComStat;
  DWORD dwErrorFlags;
  BOOL bWriteStat;
  ClearCommError(hCom,&dwErrorFlags,&ComStat);
  bWriteStat=WriteFile(hCom,lpOutBuffer,
   dwBytesWrite,& dwBytesWrite,&m_osWrite);
 
 if(!bWriteStat)
  {
   if(GetLastError()==ERROR_IO_PENDING)
   {
    WaitForSingleObject(m_osWrite.hEvent,1000);
   }
  }
 
}
 
void CRS485CommDlg::OnReceive()
 {
  // TODO: Add your control notification handler code here
  OVERLAPPED m_osRead;
  memset(&m_osRead,0,sizeof(OVERLAPPED));
  m_osRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
 
 COMSTAT ComStat;
  DWORD dwErrorFlags;
  
  char str[100];
  memset(str,''/0'',100);
  DWORD dwBytesRead=100;//读取的字节数
  BOOL bReadStat;
 
 ClearCommError(hCom,&dwErrorFlags,&ComStat);
  dwBytesRead=min(dwBytesRead, (DWORD)ComStat.cbInQue);
  bReadStat=ReadFile(hCom,str,
   dwBytesRead,&dwBytesRead,&m_osRead);
  if(!bReadStat)
  {
   if(GetLastError()==ERROR_IO_PENDING)
      //GetLastError()函数返回ERROR_IO_PENDING,表明串口正在进行读操作
   {
    WaitForSingleObject(m_osRead.hEvent,2000);
       //使用WaitForSingleObject函数等待，直到读操作完成或延时已达到2秒钟
       //当串口读操作进行完毕后，m_osRead的hEvent事件会变为有信号
   }
  }
 
 PurgeComm(hCom, PURGE_TXABORT|
   PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
  m_disp=str;
  UpdateData(FALSE);
 }
 
打开ClassWizard,为静态文本框IDC_DISP添加CString类型变量m_disp，同时添加WM_CLOSE的相应函数：
 
void CRS485CommDlg::OnClose()
 {
  // TODO: Add your message handler code here and/or call default
     CloseHandle(hCom); //程序退出时关闭串口
  CDialog::OnClose();
 }
 
您可以仔细对照这两个例程，细心体会串口同步操作和异步操作的区别。
 好了，就到这吧，祝您好运。
 
 
 
 
 
三：这部分摘自csdn的一篇论坛提问
 
 
 
同步时ReadFile会死等，但是异步的WaitForSingleObject不也会造成死等，这两种操作如果放在同一线程中有何区别呢？
 
 
 
如果你只强调在一个线程中使用的效果
 那一样
 就像用菜刀砍死一个人和用原子弹炸死一个人
 从杀死一个人的角度
 菜刀和原子弹没有区别
 
 
 
同步状态下时ReadFile这个函数只有等到读完之后才会返回，这就相当于阻塞了。
 异步状态下不是，对于ReadFileEx来说，当读写工作完成之后，会自动调用
 BOOL ReadFileEx(
   HANDLE hFile,
   LPVOID lpBuffer,
   DWORD nNumberOfBytesToRead,
   LPOVERLAPPED lpOverlapped,
   LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
 );
 中由第五个参数指定的回调函数。
 
 
 
如果像你上面所说的，那确实是同步和异步的差别，但是看到大部分没有用这种，而且用wait，所以我认为用wait跟同步没有什么区别
 
 
 
刚才看了一下，确实有用ReadFile加WaitFor...函数配合来完成异步读写的。不过这也没有什么问题啊，异步读写调用ReadFile时也是一调用即返回，至于要用WaitF...函数等待那是逻辑上的需求。
 我个人感觉用回调函数应该更合理一些。
 
 
 
我认为应该也是这样才对，可似乎网上资料都是wait，真是奇怪，难道大家用异步都是这样用不觉得有问题
 
 
 
异步的好处很多，当系统出现异常时，异步方式会更好的控制局面

  响应消息1    //来数据了

 ReadFile -> 处理数据(存盘，转发........)

 响应消息2

 消息1和消息2相差time1
 处理数据平均需要time2

 如果time1>time2,怎么写都可以
 如果time1<time2 使用异步方式很有必要
 
 
 
不排除有这可能，但如果你用了time1<time2，你确定能保证time1<time2吗，我想很少有人用这个的同时心里很有把握。
 
 
 
并不是用了time1<time2,,,,处理数据的时间只有你自己知道啊

 如果个别数据处理很费时，你就必须采用异步方式 ，并且要新开个线程，新建buf来处理数据，这样才能一边接收一边处理

 如果处理数据的时间相对于接收时间间隔来说可以忽略不计，直接处理就行了
 
 
 
我经常这样使用，开一线程同步ReadFile，读取到后放在某个缓冲区，另开线程解析（前提是通讯协议加帧头和帧尾），但是遇到应答方式通讯的协议的话，这种处理应该不是很合理，但如果同一线程中用异步WaitForSingleObject似乎跟同步区别不大。用回调肯定是个好办法
 
 
 
总结下：我个人理解，首先在底层通信上的不同导致在编程时有异步和同步的选择；其次异步通信旨在让函数运行更灵活（回调是一种体现，利用空闲时间做解析操作也是一种体现），具体还要自己编程运用到才能更好的理解。
 
 
 
这方面的心得以后还会继续完善更新。。。
 
 
 
转自：https://blog.csdn.net/cs74184235/article/details/48438727
 
 

 
文章目录
 
一、串口通信
二、异步通信
三、同步通信
四、串行通信的传输方向
 

 
一、串口通信
 
1、随着多微机系统的广泛应用和计算机网络技术的普及，计算机的通信功能愈来愈显得重要。计算机通信是指计算机与外部设备或计算机与计算机之间的信息交换。
 
2、通信有并行通信和串行通信两种方式。在多微机系统以及现代测控系统中信息的交换多采用串行通信方式。
 计算机通信是将计算机技术和通信技术的相结合，完成计算机与外部设备或计算机与计算机之间的信息交换。
 
3、可以分为两大类：并行通信与串行通信。
 
4、并行通信
 通常是将数据字节的各位用多条数据线同时进行传送。并行通信控制简单、传输速度快，由于传输线较多，长距离传送时成本高且接收方的各位同时接收存在困难。
 
 
5、串行通信
 串行通信是将数据字节分成一位一位的形式在一条传输线上逐个地传送。
 串行通信的特点:传输线少，长距离传送时成本低,且可以利用电话网等现成的设备，但数据的传送控制比并行通信复杂。
 
 
二、异步通信
 
1、异步通信
 异步通信是指通信的发送与接收设备使用各自的时钟控制数据的发送和接收过程。为使双方的收发协调，要求发送和接收设备的时钟尽可能一致。
 
 
2、异步通信的数据格式
 
 
（1）SYN：同步字符(Synchronouscharacter)，每帧可加1个（单同步）或2个（双同步）同步字符。
 
（2）SOH：标题开始(Start of Header)。
 
（3）标题：Header，包含源地址（发送方地址）、目的地址（接收方地址）、路由指示。
 
（4）STX：正文开始(Start of Text)。
 
（5）数据块：正文(Text)，由多个字符组成。
 
（6）ETB：块传输结束（End of TransmissionBlock），标识本数据块结束。
 
（7）ETX：全文结束（End of Text ），全文分为若干块传输。
 
（8）校验块：对从SOH 开始，直到ETB/ETX 字段的检验码。
 
3、异步通信原理
 异步通信是以字符（构成的帧)为单位进行传输,字符与字符之间的间隙(时间间隔）是任意的，但每个字符中的各位是以固定的时间传送的,即字符之间不一定有“位间隔”的整数倍的关系，但同一字符内的各位之间的距离均为“位间隔”的整数倍。
 
4、异步通信的特点
 本要求收发双方时钟的严格一致,实现容易，设备开销较小，但每个字符要附加2～3位用于起止位，各帧之间还有间隔，因此传输效率不高。
 
三、同步通信
 
1、同步通信
 同步通信（由一个时钟控制，用得很少，单片机是异步通信）
 
 
2、同步通信的优势
 同步通信时要建立发送方时钟对接收方时钟的直接控制,使双方达到完全同步。此时，传输数据的位之间的距离均为“位间隔”的整数倍，同时传送的字符间不留间隙,即保持位同步关系，也保持字符同步关系。发送方对接收方的同步可以通过两种方法实现。
 
四、串行通信的传输方向
 
1、单工
 单工是指数据传输仅能沿一个方向，不能实现反向传输。
 
2、半双工
 半双工是指数据传输可以沿两个方向，但需要分时进行。
 
3、全双工
 全双工是指数据可以同时进行双向传输
 
 
4、信号的调制与解调
 利用调制器(Modulator)：把数字信号转换成模拟信号，然后送到通信线路上去，再由解调器(Demodulator)把从通信线路上收到的模拟信号转换成数字信号。由于通信是双向的,调制器和解调器合并在一个装置中，这就是调制解调器MODEM。
 
5、80C51的串行口结构
 

 
文章目录
 
Win10 串口通信 —— 同步/异步
简介
实现
1.主函数
2.串口模块
   
源码
 

 
Win10 串口通信 —— 同步/异步
 
简介
 
之前接到的一个小项目，好像不能算。win10下的串口通信，不需要界面，排除了Qt,MFC只剩C++ 底层了，调用WindowsApi来实现。翻了翻网上资料大致写出来了。
 
 
CSDN地址：通信相关
 
 
Git地址:https://github.com/ayowin/WZSerialPort
 
 
串口调试工具：https://gitee.com/fengmeitech/Micro-Lab
 
 
虚拟串口工具：https://blog.csdn.net/qq_34202873/article/details/88391265
 
 
 
 
系统环境：Win10
 
 
IDE: VS2017
 
 
编译器：MSVC2017/C++11
 
 
实现
 
主要分为接收线程和主线程调度模块，由于没有共用数据体，就没有做线程锁。底层串口模块主要调用 上述git上的源码。WzSerialPort，并做了一些简单修改，实现了异步串口通信。
 
1.主函数
 
入口说明 - 提示
 
void showHelp()
{
	std::cout << " portname(串口名): 在Windows下是\"COM1\"\"COM2\"" << std::endl;
	std::cout << " baudrate(波特率): 9600、19200、38400、43000、56000、57600、115200 " << std::endl;
	std::cout << " parity(校验位): 0为无校验，1为奇校验，2为偶校验，3为标记校验" << std::endl;
	std::cout << " databit(数据位): 4-8(windows),通常为8位" << std::endl;
	std::cout << " stopbit(停止位): 1为1位停止位，2为2位停止位,3为1.5位停止位" << std::endl;
}
 
入口说明-main函数
 
	bool isHelp = false;
	std::cout << "请输入是否查看帮助（0：不查看 1：查看）：";
	std::cin >> isHelp;
	if (isHelp) showHelp();

	std::string comName;
	std::cout << "请输入串口名称: ";
	std::cin >> comName;

	int bata = 0;
	std::cout << "请输入波特率：";
	std::cin >> bata;
	int checkBit = 0;

	std::cout << "请输入校验位：";
	std::cin >> checkBit;

	std::cout << "数据位默认为：8，停止位默认为：0" << std::endl;
	std::cout << "ComName:" << comName << " BaudRate:" << bata << " Parity:" << checkBit << std::endl;
	std::cout << "" << std::endl;
	std::cout << "---------------------" << std::endl;
 
入口函数-串口初始化
 
	WzSerialPort w;
	serialPortInit(w,comName,bata, checkBit);
 
bool serialPortInit(WzSerialPort &w, std::string  comName, int bata, int checkBit)
{
	bool ret = false;
	if (w.open(comName.c_str(), bata, checkBit, 8, 1, 0))
	{
		ret = true;
		std::cout << "SerialPort Init OK!" << std::endl;
	}
	else
		std::cout << "SerialPort Init Fail!" << std::endl;
	return ret;
}
 
接收线程 - 因为只是单纯的数据显示，并没有做数据解析
 
void receiveDemo(WzSerialPort w)
{
	char buf[1024];
	bool runFlag = true;
	while (runFlag)
	{
		if (closeFlag) runFlag = false;
		memset(buf, 0, 1024);
		if(w.receive(buf, 1024))
			std::cout << "接收数据为： " << buf << std::endl;
		Sleep(200);
	}
}
 
std::thread recv(receiveDemo, w); //线程启动
recv.detach(); //线程分离
 
主线程-发送
 
	while (true)
	{
		int type = 0;
		std::cin >>  type;
		if (type == 15)
		{
			closeFlag = true;
			w.close();
			break;
		}
		sendThread(w,type);
	}
	std::cout << "程序退出成功" << std::endl;
 
void sendThread(WzSerialPort w,int type)
{
	protocol pro;
	getCmdData(pro, type);
	if (sendDemo(w, &pro, sizeof(pro)))
		std::cout << "数据发送完成！发送类型: " << type << " len:" << sizeof(pro) << std::endl;
	else
		std::cout << "数据发送失败！" << std::endl;
	std::cout << "请输入发送类型：" << std::endl;
}
 
bool sendDemo(WzSerialPort w, const void* buf,int len)
{	
	if (w.send(buf, len) == 0)
	{
		std::cout << "send data fail" << std::endl;
		return false;
	}
	return true;
}
 
数据结构体、字转换、数据拼装
 
bool closeFlag = false;
#pragma pack(1) //设置为一字节对齐
typedef struct 
{
	unsigned short header; //数据头
	unsigned char devNo; //设备节点
	unsigned char len; //数据长度
	unsigned char cmd; //命令
	unsigned short data; //数据内容
}protocol,*pProtocol;

//大小端转换函数
unsigned short BLEndianUshort(unsigned short value)
{
	return ((value & 0x00FF) << 8) | ((value & 0xFF00) >> 8);
}
//因为数据格式为固定，这里边就写死了，根据实际需要来做修改。
void getCmdData(protocol &pro, int type)
{
	if (type > 14 || type < 0)
	{
		std::cout << "输入类型错误！请重新输入！" << std::endl;
	}
	pro.header = BLEndianUshort(0XAA96);
	pro.devNo = 0X00;
	pro.len = 0X03;
	pro.cmd = 0X01;
	pro.data = BLEndianUshort(data[type]);
}
 
2.串口模块
 
只做一些简单说明，为什么上述博文中说明异步通信为什么没有实现，把错误地方给贴出来修改。
 
利用WindowsAPI实现，C++实现，在windows系统，移植或者适用匹配度很高。
 
修改部分，最先测试同步通信一直没有问题，异步通信没有实现。
 
修改部分 - 头文件说明 – 同步异步 之前为 1异步 0 同步 --实际代码中 1为同步，0为异步，默认同步
 
	// 打开串口,成功返回true，失败返回false
	// portname(串口名): 在Windows下是"COM1""COM2"等，在Linux下是"/dev/ttyS1"等
	// baudrate(波特率): 9600、19200、38400、43000、56000、57600、115200 
	// parity(校验位): 0为无校验，1为奇校验，2为偶校验，3为标记校验（仅适用于windows)
	// databit(数据位): 4-8(windows),5-8(linux)，通常为8位
	// stopbit(停止位): 1为1位停止位，2为2位停止位,3为1.5位停止位
	// synchronizeflag(同步、异步,仅适用与windows): 0为异步，1为同步
	bool open(const char* portname, int baudrate, char parity, char databit, char stopbit, char synchronizeflag=1);
 
 
修改部分-发送部分–异步发送一直为失败。
 
  
 
   
WaitForSingleObject(m_osWrite.hEvent, 1000); 原先为并没有对等待写入事件成功失败处理，主要是成功，成功为发送成功，但返回值还为0.所以在主线程做发送判断时会一直提示失败，此处做修改，实现异步通信
 
  
 
 
int WzSerialPort::send(const void *buf,int len)
{
	HANDLE hCom = *(HANDLE*)pHandle;

	if (this->synchronizeflag)
	{
		// 同步方式
		DWORD dwBytesWrite = len; //成功写入的数据字节数
		BOOL bWriteStat = WriteFile(hCom, //串口句柄
									buf, //数据首地址
									dwBytesWrite, //要发送的数据字节数
									&dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
									NULL); //NULL为同步发送，OVERLAPPED*为异步发送
		if (!bWriteStat)
		{
			return 0;
		}
		return dwBytesWrite;
	}
	else
	{
		//异步方式
		DWORD dwBytesWrite = len; //成功写入的数据字节数
		DWORD dwErrorFlags; //错误标志
		COMSTAT comStat; //通讯状态
		OVERLAPPED m_osWrite; //异步输入输出结构体

		//创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
		memset(&m_osWrite, 0, sizeof(m_osWrite));
		m_osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, L"WriteEvent");

		ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误，获得设备当前状态
		BOOL bWriteStat = WriteFile(hCom, //串口句柄
			buf, //数据首地址
			dwBytesWrite, //要发送的数据字节数
			&dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
			&m_osWrite); //NULL为同步发送，OVERLAPPED*为异步发送
		if (!bWriteStat)
		{
			if (GetLastError() == ERROR_IO_PENDING) //如果串口正在写入
			{
                //WaitForSingleObject(m_osWrite.hEvent, 1000); 原先为并没有对等待写入事件成功失败处理，主要是成功，成功为发送成功，但返回值还为0.所以在主线程做发送判断时会一直提示失败，此处做修改，实现异步通信
				if (WaitForSingleObject(m_osWrite.hEvent, 1000) == WAIT_OBJECT_0) //等待写入事件1秒钟
				{
					bWriteStat = true;	//写入事件完成，修改写入状态
					dwBytesWrite = len; //修改写入字节长度为实际字节长度
				}
			}
			else
			{
				ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
				CloseHandle(m_osWrite.hEvent); //关闭并释放hEvent内存
				return 0;
			}
		}
		return dwBytesWrite;
	}
}

```

 
源码
 
等待上传中，上传成功做修改。

一、串口通信简介
 
串口通信，顾名思义也就是利用串行接口进行通信。串行接口指串口按位（bit）发送和接收字节。尽管比按字节（byte）传输的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。
 
串口通信中比较重要的参数包括波特率、数据位、停止位及校验位，通讯双方需要约定一致的数据格式才能正常收发数据。串行通讯可以进一步分为单工、半双工和全双工三种。在串口通信中，常用的协议包括RS-232、RS-422和RS-485。它们的主要区别在于其各自的电平范围不相同。
 
二、串行和并行通信
 
刚说到串口通信是通过接口进行串行通讯。那么什么是串行通讯呢？
 
1 串行通信：
 
串行通信：计算机与I/O设备之间，同一时刻，只能传输一个bit位的信号。传输数据按顺序依次一bit位接一bit位进行传输，通常数据在一根数据线或一对差分线上传输。
 
比如，当传输1字节信息时，并行通讯有8根信号线实现同时传输，假如耗时为1T，而串行是在一根信号线上，把数据排成一行、一位一位传输，需要传8次，因此耗时为8T。因此可总结出二者的特性：
 
2 并行通信：
 
并行通信是和串行通信相对的数据传输的方式。
 
并行通信：计算机与I/O设备之间，通过多条传输线，可以同时传输多个bit位的信号。
 
 
并行通讯的效率高，但是成本高、对信号线路要求高，一般应用于快速设备之间近距离传输，譬如CPU 与存储设备、存储器与存储器、主机与打印机等都采用并行通讯。
 
 
串行通讯效率较低，但是对信号线路要求低，抗干扰能力强，同时成本也相对较低，一般用于计算机与计算机、计算机与外设之间远距离通讯。
 
 
3 串口通信和串行通信的区别
 
串口通信和串行通信的区别在于：串行通信是一种概念，串口通信是一种具体的通信手段。
 
串行通信是一种概念，是指一比特一比特的收发数据，相对于并行通信可同时传输多个bit位而言。包括一般的的串口通信、I2C、SPI等等。
 
串口通信是外设和计算机间的一种通信手段，是相对于以太网通信等通信手段而言的。
 
二者一个是一种概念，一个是一种实际的通信方式。
 
三、同步和异步通信
 
在设备之间传送数据，不管是同步通信还是异步通信，都是为了保证数据被正确的发送和接收，即发送方和接收方的“同步”。即接收方可以确定什么时候发送方开始或者结束发送数据以及每一个数据单位（例如bit，字符）的开始和结束的位置，这样接收方才能在正确的时间对发送方的数据进行采样，以接收正确的数据，否则接收到的数据就是错误的。
 
根据“同步方式”的不同，由此分出两种同步信号得方法：
 （1）同步通信（比特位同步）
 （2）异步通信（字符间同步，字符内比特位异步）
 
同步通信会利用一根额外的信号线，其实也就是时钟信号线，它往往是发送设备提供的时钟信号，发送设备和接收设备在发送设备提供的同一时钟频率下完成同步。（实际上，基本所有的并行通信采用同步通信。）
 
异步通信没有额外的一根信号线用于同步，接收者和发送者使用各自的时钟信号，接收者根据与发送者按事先约定的规来确定数据发送的开始与结束以及数据单位的持续时间。例如异步串行通信中，一般接收双方会确定一致的停止位，数据位的个数、波特率的大小以及是否采用奇偶校验位。接收方可以根据这些信息推测出准确的数据采样时间以接收正确的数据。如果是同步通信则不需要这些额外的用于同步的数据位（开始位，结束位，奇偶校验位）。
 
1 同步通信
 
同步通信要求发送和接收双方在进行数据传输时，保持完全的同步，因此，要求发收双方必须使用同频同相的同步时钟信号。只需在传送报文的最前面附加特定的同步字符，使发收双方建立同步，此后在同步时钟的控制下逐位发送/接收。这样，信息传输完全可以确定传输过程中每1位的位置。因此同步通信是一种比特同步通信技术。
 
如下图所示：
 
 
同步通信是一种连续传送数据的通信方式，一次通信传送一帧数据，每个信息帧用同步字符作为开始，字符间不加标识位。（这里的数据帧比异步通信中的字符帧要大得多，通常含有若干个数据字符）。当检测到有一串数位和同步字符相匹配时，就认为开始一个信息帧，于是，把此后的数位作为实际传输信息来处理。
 
同步通信以数据帧为单位，其格式包括：同步字符+数据+校验字符CRC。
 
（a）单同步数据帧结构
 
同步字符
数据字符1
数据字符2
数据字符3
…
数据字符n
CRC1
CRC1

（b）双同步数据帧结构
 
同步字符1
同步字符2
数据字符1
数据字符2
…
数据字符n
CRC1
CRC1

没有数据发送时，接收方要时刻做好接收数据的准备。在每组信息（通常称为帧）传输的开始，发送方先发送一个或两个特殊字符，该字符称为同步字符。当接收方收到同步字符，并和发送方达到同步后，就可以以固定的节奏一个字符接一个字符地发送一大块数据，而不再需要用起始位和停止位了，这样可以明显地提高数据的传输速率。同步通信更加适合对速度要求高的传输，对时序的要求很高，当然对硬件要求也更高。
 
在没有信息要传输时，要填上空字符，因为同步传输不允许有间隙。在同步传输过程中，一个字符可以对应5～8位。当然，对同一个传输过程，所有字符对应同样的数位，比如说n位。这样，传输时，收发双方用一个时钟进行协调，按每n位划分为一个时间片，发送端在一个时间片中发送一个字符，接收端则在一个时间片中接收一个字符，这样就可以确定传输中每一位的位置。接收数据时，接收方利用同步字符使内部时钟与发送方保持同步，然后将同步字符后面的数据逐位移入，并转换成并行格式，供CPU读取，直至收到结束符为止。
 
2 异步通信
 
异步通信是按字符帧传输的，相对于同步通信，异步通信在发送字符时，所发送的字符之间的时隙可以是任意的，接收方并不知道数据什么时候会到达，因此接收端必须时刻做好接收的准备（如果接收端主机的电源都没有加上，那么发送端发送字符就没有意义，因为接收端根本无法接收）。发送端可以在任意时刻开始发送字符，时间间隔可以是任意的，在一字符帧中的所有比特是连续发送的。
 
发送端不需要在发送字符之前和接收端进行协调（不需要先进行比特同步）。接收设备在收到起始信号之后只要在一个字符的传输时间内能和发送设备保持同步就能正确接收。内部处理器在完成了相应的操作后，通过一个回调的机制，以便通知发送端发送的字符已经得到了回复。下一个字符起始位的到来又使同步重新校准(依靠检测起始位来实现发送与接收方的时钟自同步的字符间同步，字符内比特位异步)
 
因此必须在每一个字符的开始和结束的地方加上标志，即加上开始位和停止位，以便使接收端能够正确地将每一个字符接收下来。通信双方需要对采用的信息格式（字符的位数、停止位的位数、有无校验位及校验方式等)和数据的传输速率作相同的约定。接收方是在数据的起始位和停止位的帮助下实现字符传送时的同步。这种传输通常是很小的分组，比如一个字符为一组，为这个组配备起始位和结束位。所以这种传输方式的效率是比较低的，毕竟额外加入了很多的辅助位作为负载，常用在低速的传输中。
 

 异步通信以字符为单位，其格式包括：起始位+数据+奇偶校验位+停止位。
 以起止式异步协议为例，如下图所示
 
 　　起止式异步通信的特点是：一个字符一个字符地传输,每个字符一位一位地传输，并且传输一个字符时，总是以"起始位"开始，以"停止位"结束，字符之间没有固定的时间间隔要求。每一个字符的前面都有一位低电平起始位(逻辑值0)，字符本身由5-8位数据位组成，接着字符后面是一位校验位(也可以没有校验位),最后是一位或一位半或二位停止位,停止位后面是不定长的空闲位。停止位和空闲位都规定为高电平(逻辑值１)，这样就保证起始位开始处一定有一个下跳沿。由此就可以标志一个字符传输的起始。而根据起始位和停止位也就很容易的实现了字符的界定和同步。
 　　如上图中所示，这种格式是靠起始位和停止位来实现字符的界定或同步的，故称为起止式协议。
 　　
 （1）起始位：发送数据时，先发持续一个bit时间的逻辑”0”信号，表示字符传输的开始，接收端可根据起始位使自己的接收时钟与发送方的数据同步。
 
（2）数据位：起始位后是数据位，异步传送规定低位在前，高位在后，数据位的位数一般可以是5～8位。
 
（3）奇偶校验位：奇偶位紧跟在数据最高位之后，占用一位（也可省去）。加上这一位后，使得逻辑“1”信号的位数得到偶校验或奇校验，以此来校验数据传送的正确性。
 　　如果是奇校验，需要保证传输的数据总共有奇数个逻辑高位；如果是偶校验，需要保证传输的数据总共有偶数个逻辑高位。举例来说，假设传输的数据位为01001100，如果是奇校验，则奇校验位为0（要确保总共有奇数个1），如果是偶校验，则偶校验位为1（要确保总共有偶数个1）。
 　　由此可见，奇偶校验位仅是对数据进行简单的置逻辑高位或逻辑低位，不会对数据进行实质的判断，这样做的好处是接收设备能够知道一个位的状态，有可能判断是否有噪声干扰了通信以及传输的数据是否同步。
 
（4）停止位：数据发送完后，再发1位、1.5位、2位的高电平（逻辑”1”信号）代表停止位，表示一帧数据结束，同时为接收下一帧数据做准备。
 
（5）空闲位：在没有数据发送时，即下一帧的起始位“0”到来之前，数据线保持默认的“1”状态，即由高电平来填充。
 
异步通信字符帧格式总结如下表：
 
逻辑信号
数据位数
起始位
0
1位
数据位
0或1
5～8位
校验位
0或1
1位或无
停止位
1
1位，1.5位或2位
空闲位
1
任意数量
注：位数的本质含义是信号持续的时间,故可有分数位,如停止位1.5位，1.5是它的长度，即停止位的电平保持1.5个单位时间长度。一个单位时间就是波特率的倒数，例如波特率为9600bps，则一个单位时间长为1/9600s，1.5个停止位，即停止位电平保持1.5/9600s。
 
3 同步通信和异步通信比较
 
（1）同步通信要求接收端时钟频率和发送端时钟频率一致；异步通信时不要求接收端时钟和发送端时钟同步。
 
（2）同步通信数据传输是以字节块(多个字节)传输的；异步通信数据传输是以字符(一个字节）传输的。
 
（3）同步通信传输效率高，但复杂、要求高，双方时钟的允许误差较小；异步通信传输效率低，但简单、要求低，双方时钟可允许一定误差。
 
（4）同步通信的字节传输是没有间隔的发送端发送连续的比特流；异步通信字节传送的间隔是任意的，发送端发送完一个字节后，可经过任意长的时间间隔再发送下一个字节。
 
同步通信和异步通信的差异总结如下表：
 
同步通信
异步通信
传送单位
信息帧（由若干字符组成的数据块）
字符（由若干bit组成）
单位格式
同步字符+数据+校验字符CRC
起始位+数据位+奇偶校验位+停止位
传送间隔
一个数据块（信息帧）内，字符与字符间无间隔
相邻两字符之间隔任意长
时钟信号
时序要求高，使用同频同相的时钟线路
时序要求较低，使用各自的时钟信号
优点
效率高
简单，要求低
缺点
复杂，要求高
效率低（传送一个字符，要增加约20％的附加信息位）