关闭

Windows API串口编程参考

标签: windows
1486人阅读 评论(1) 收藏 举报
分类:

(一)Windows API串口通信编程概述

Windows环境下的串口编程与DOS环境下的串口编程有很大不同。Windows环境下的编程的最大特征之一就是设备无关性,它通过设备驱动程序将Windows应用程序同不同的外部设备隔离。Windows封装了Windows的通信机制,这种方式称为通信API,Windows程序可以利用Windows通信API进行编程,不用对硬件直接进行操作。这种体系被称为Windows开放式服务体系(WOSA,Windows Open Services Architectures)。

早期的Windows3.x与Windows 9x/NT/2000的通信API有很大不同,在16位的串行通信程序中,一般使用16位的Windows API通信函数。为使大家对串口通信有一全面的理解,下面简单介绍一下16位的Windows API通信函数:

(1)       打开和关闭串口

OpenComm()打开串口资源,并指定输入、输出缓冲区的大小(以字节计);

CloseComm()关闭串口;

例:

int idComDev;

idComdev=OpenComm(“COM1”,1024,512);

CloseComm(idComDev);

(2)       初始化串口

BuildCommDCB()、setCommState()填写设备控制块DCB,然后对已打开的串口进行参数配置,例:

DCB dcb;

BuildCommDCB(〝COM1:2400,n,8,1〞,&dcb);

SetCommState(&dcb);

(3)       对串口进行读写

ReadComm、WriteComm()对串口进行读写操作,即数据的接收和发送。例:

char *m_pReceive; int count;

ReadComm(idComDev,m_pReceive,count);

 

 

Char wr[30]; int count2;

WriteComm(idComDev,wr,count2);

通过对以上的描述我们可以看出,16位以下的串口通信程序最大的特点就在于串口等外部设备的操作有自己特有的API函数。

Windows 9x/NT/2000中的API一般都支持32位的操作,因此又称为Win32API。为了在上述系统中实现串行数据传送,可以使用Win32通信API。Win32通信API基本上是一个串行端口API,不是很适合于局域网(LAN)通信。虽然在线路上发送数据之前,LAN通常将数据位串行化,这和窗口或调制解调器发送数据之前所作的工作一模一样,但局域网使用的线路的位数通常比串口少,而且还使用与串口协议很少有类似之处的访问、路由、安全性和纠错协议。局域网通信所需要的协议层使得Win32通信API对于这些应用来说很不理想。因此,在网络通信和连接方面,TCP/IP协议要比Win32通信API更适合一些。

Windows操作系统是一个可抢占式的操作系统,所以Windows应用程序常常有被别的程序抢占时间片的可能,因此Win32通信API也不能用于实时通信。实时通信的质量与时间密切相关。例如,数字化音频数据是实时数据,因为话音的质量依赖于播放它的速率。在录制音频时,它就以某个速度被数字化了,该速度就是人们所熟知的采样速率。声音必须以相同的采样率重放,否则听起来就会太慢或太快。实际中的视频播放,也不是实时播放,那仅仅是存放在缓冲中的那部分数据。因此,不需要许多协议层的交互式、非实时的通信可以采用Win32通信API来实现。Win32通信API把串口操作(以及并口等)和文件操作统一起来了,使用类似的操作来实现。

 

(二)  Windows串口通信相关API函数

“工欲善其事,必先利其器”,这一节将从使用的角度出发,对和串口通信相关的32位的Windows API函数进行介绍,力图使你们对其有个全面、准确的认识。

 

2.1   打开和关闭串口

1.  打开串口

在32位的Windows系统中,串口和其它通信设备是作为文件处理的。串口的打开、关闭、读取和写入所用的函数与操作文件的函数完全一致。

通信会话以调用CreateFile()开始。CreateFile()为读访问、写访问或读写访问“打开”串口。按照Windows的通常做法,CreateFile()返回一个句柄,随后在打开的端口的操作中使用CreateFile()函数非常复杂,复杂性的原因之一是它是通用的。可以使用CreateFile打开已存在的文件,创建新文件和打开根本就不是文件的设备,例如串口、并口和调制解调器。CreateFile()函数声明如下:

HANDLE CreateFile(

  LPCTSTR lpszName,

  DWORD fdwAccess,

  DWORD fdwShareMode,

  LPSECURITY_ATTRIBUTES lpsa,

  DWORD fdwCreate,

  DWORD fdwAttrsAndFlags,

  HANDLE hTemplateFile

 )

 CreateFile函数中的参数解释如下:

·lpszName:指定要打开的串口逻辑名,用字符串表示,如“COM1”和“COM2”分别表示串口1和串口2。

·fdwAccess:用来指定串口访问的类型。与文件一样,串口也是可以被打开以供读取、写入或者两者兼有。

 GENERIC_READ位读取访问打开端口,GENERIC_READ位写访问打开端口。这两个常数定义如下:

const GENERIC_READ = 0x80000000h;

const GENERIC_WRITE = 0x40000000h;

用户可以用逻辑操作将这两个标识符连接起来,为读/写访问权限打开端口。因为大部分串口通信都是双向的,因此常常在设置中将两个标识符连接起来使用。如:

fdwAccess = GENERIC_READ | GENERIC_WRITE;

·fdwShareMode:指定该端口的共享属性。该参数是为那些由许多应用程序共享的文件提供的。对于不能共享的串口,它必须设置为0。这就是文件与通信设备之间的主要差异之一。如果在当前的应用程序调用CreateFile()时,另一个应用程序已经打开了串口,该函数就会返回错误代码,原因是两个应用程序不能共享一个端口。然而,同一个应用程序的多个线程可以共享由CreateFile()返回的端口句柄,并且根据安全性属性设置,该句柄可以被打开端口的应用程序的子程序所继承。

·Ipsa:引用安全性属性结构(SECURITY_ARRTIBUTES),该结构定义了一些属性,例如通信句柄如何被打开端口的应用程序的子程序所继承。将该参数设置为NULL将为该端口分配缺省的安全性属性。子应用程序所继承的缺省属性是该端口不能被继承的。

安全属性结构SECURITY_ARRTIBUTES结构声明如下:

typedef struct_SECURITY_ARRTIBUTE {

    DWORD nLength;

    LPVOID lpSecurityDescriptor;

    BOOL  bInheritHandle;

} SECURITY_ARRTIBUTE;

SECURITY_ARRTIBUTES结构成员nLength指明该结构的长度,lpSecurityDescriptor指向一个安全描述字符,bInheritHandle表明句柄是否能被继承。

·fdwCreate:指定如果CreateFile()正在被已有的文件调用时应采取的动作。因为串口总是存在,fdwCreate必须设置成OPEN_EXISTING。该标志告诉Windows不用企图创建新端口,而是打开已经存在的端口。OPEN_EXISTING常数定义为:

const OPEN_EXISTING = 3;

·fdwAttrsAndFlags:描述了端口的各种属性。对于文件来说,有可能具有很多属性,但对于串口,唯一有意义的设置是FILE_FLAG_OVERLAPPED。当创建时指定该设置,端口I/O可以在后台进行(后台I/O也叫异步I/O)。FILE_FLAG_OVERLAPPED常数定义如下:

const FILE_FLAG_OVERLAPPED = 0x40000000h

·hTemplateFile:指向模板文件的句柄,当端口处于打开状态时,不使用该参数,因而必须置成0。

调用CreateFile()函数打开COM1串口操作的例子如下所示:

HANDLE hCom;

DWORD dwError;

 

 

hCom=CreateFile(“COM1”, // 文件名

GENERIC_READ | GENERIC_WRITE, // 允许读和写

0, // 独占方式

NULL,

OPEN_EXISTING, // 打开而不是创建

FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, // 重叠方式

NULL

);

if(hCom = = INVALID_HANDLE_VALUE)

{

dwError=GetLastError(); // 处理错误

}

一旦端口处于打开状态,就可以分配一个发送缓冲区和接收缓冲区,并且通过调用SetupComm()实现其它初始化工作。也可以不调用SetupComm()函数,Windows系统也会分配缺省的发送和接收缓冲区,并且初始化端口。但为了保证缓冲区的大小与实际需要的一致,最好还是调用该函数。SetupComm()函数声明如下:

BOOL SetupComm(

HANDLE hFile, // 通信设备句柄

DWORD dwInQueue, // 输入缓冲区大小

DWORD dwOutQueue // 输出缓冲区大小

);

SetupComm()函数中各项含义说明如下:

·hFile: 由GreatFile()返回的指向已打开端口的句柄。

·dwInQueue和dwOutQueue: 接收缓冲区的大小和发送缓冲区的大小。这两个定义并非是实际的缓冲区的大小,指定的大小仅仅是“推荐的”大小,而Windows可以随意分配任意大小的缓冲区。Windows设备驱动程序可以获得这两个数据,并不直接分配大小,而使用来优化性能和避免缓冲区超限。

注意:当使用CreateFile()函数打开串口时:为实现调制解调器的排他性访问,共享标识必须设为零;创建标识必须设为OPEN_EXISTING;模板句柄必须置为空。

2.  关闭串口

关闭串口比打开串口简单得多,只需要调用CloseHandle()函数关闭由CreateHandle()函数返回得句柄即可。

CloseHandle函数声明如下:

BOOL CloseHandle(

  HANDLE hObject   // 需关闭的设备句柄

);

使用串口时一般要关闭它,如果忘记关闭串口,串口就会始终处于打开状态,其它应用程序就不能打开并使用串口了。

 

2.2   串口配置和串口属性

Windows 9x/NT/2000中配置串口提供了比Windows的早期版本更为强大的功能,当然相应也更加复杂。CreateFile函数打开串口后,系统将根据上次打开串口时设置的值来初始化串口,可以集成上次打开操作后的数值,包括设备控制块(DCB)和超时控制结构(COMMTIMEOUTS)。如果是首次打开串口,Windows操作系统就会使用缺省的配置。

1.  串口配置

Windows 9x/NT/2000使用GetCommState()函数获取串口的当前配置,使用SetCommState()重新分配串口资源的各个参数。

GetCommState()函数声明如下:

BOOL GetCommState(

   HANDLE hFile, // 通信设备句柄

   LPDCB lpDCB   // 指向device-control block structure的指针

);

其中的参数说明如下:

·hFile:由CreateFile()函数返回的指向已打开串口的句柄。

·lpDCB:一个非常重要的结构—设备控制块DCB ( Device Control Block )。

DCB结构的主要参数说明如下:

·DCBLength: 一字节为单位指定的DCB结构的大小。

·Baudrate: 用于指定串口设备通信的数据传输速率,它可以是实际的数据传输速率数值,也可以是下列数据之一:CBR_110, CBR_19200, CBR_300, CBR_38400, CBR_600, CBR_56000, CBR_1200, CBR_57600, CBR_2400, CBR_115200, CBR_4800, CBR_12800, CBR_9600, CBR_25600, CBR_14400。

·fBinary: 指定是否允许二进制。Win32API不支持非二进制传输,因此这个参数必须设置为TRUE,如果设置为FALSE则不能正常工作。

·fParity: 指定是否允许奇偶校验,如果这个参数设置为TRUE,则执行奇偶校验并报告错误信息。

·fOutxCtsFlow: 指定CTS是否用于检测发送流控制。当该成员为TRUE,而CTS为OFF时,发送将被挂起,直到CTS置ON。

·fOutxDsrFlow: 指定DSR是否用于检测发送流控制,当该成员为TRUE,而DSR为OFF时,发送将被挂起,直到DSR置ON。

·fDtrControl: 指定DTR流量控制,可以是表1中的任一值。

表1                           DTR流量控制

                      值

              功能描述

        DTR_CONTROL_DISABLE

禁止DTR线,并保持禁止状态

        DTR_CONTROL_ENABLE

允许DTR线,并保持允许状态

        DTR_CONTROL_HANDSHAKE

允许DTR握手,如果允许握手,则不允许应用程序使用EscapeCommFunction函数调整线路

·fDsrSensitivity: 指定通信驱动程序对DTR信号线是否敏感,如果该位置设为TRUE时,DSR信号为OFF,接收的任何字节将被忽略。

·fTXContinueOnXoff: 指定当接收缓冲区已满,并且驱动程序已经发送出XoffChar字符时发送是否停止。当该成员为TRUE时,在接收缓冲区内接收到了缓冲区已满的字节XoffLim,并且驱动程序已经发送出XoffChar字符终止接收字节之后,发送继续进行。该成员为FALSE时,接收缓冲区接收到代表缓冲区已空的字节XonLim,并且驱动程序已经发送出恢复发送的XonChar字符后,发送可以继续进行。

·fOutX: 该成员为TRUE时,接收到XoffChar之后停止发送,接收到XonChar之后发送将重新开始。

·fInX: 该成员为TRUE时,接收缓冲区内接收到代表缓冲区满的字节XoffLim之后,XoffChar发送出去,接收缓冲区接收到代表缓冲区已空的字节XonLim之后,XonChar发送出去。

·fErrorChar: 当该成员为TRUE,并且fParity为TRUE时,就会用ErrorChar成员指定的字符来代替奇偶校验错误的接收字符。

·fNull: 指明是否丢弃接收到的NULL( ASCII 0 )字符,该成员为TRUE时,接收时去掉空(零值)字节;反之则不丢弃。

表2                        RTS 流量控制

                  值

           功能描述

RTS_CONTROL_DISABLE

打开设备时禁止RTS线,并保持禁止状态

RTS_CONTROL_ENABLE

打开设备时允许RTS线,并保持允许状态

DTR_CONTROL_HANDSHAKE

允许握手。在接收缓冲区小于半满时将RTS 置为ON,在接收缓冲区超过3/4时将RTS置为OFF。如果允许握手,则不允许应用程序使用EscapeCommFunction函数调整线路

DTR_CONTROL_TOGGLE

当发送的字节有效,将RTS置为 ON,发送完缓冲区的所有字节后, RTS置为OFF

·fRtsControl: 指定  RTS 流量控制,可以取表2中的值。0值和DTR_CONTROL_HANDSHAKE等价。

·fAbortOnError: 如果发送错误,指定是否可以终止读、写操作。如果该位为TRUE,当发生错误时,驱动程序以出错状态终止所有的读写操作。只有当应用程序调用ClearCommError()函数处理后,串口才能接收随后的通信操作。

·fDummy2: 保留的位,没有使用。

·wReserved:没有使用,必须为零。

·XonLim: 指定在XOFF字符发送之前接收到缓冲区中可允许的最小字节数。

·XoffLim: 指定在XOFF字符发送之前缓冲区中可允许的最小可用字节数

·ByteSize: 指定端口当前使用的数据位数。

·Parity: 指定端口当前使用的奇偶校验方法。它的可能值如表3所示。

·StopBits: 指定串口当前使用的停止位数,可能值如表4所示。

表3                           奇偶校验方法

                 

               功能描述

          EVENPARITY

            偶校验

          MARKPARITY

            标号校验

          NOPARITY

            无校验

          ODDPARITY

            奇校验

          SPACEPARITY

            空格效益

 

表4                           停止位数描述

                 

                功能描述

          ONESTOPBIT

              1位停止位

          ONE5STOPBITS

              1.5位停止位

          TWOSTOPBITS

              2位停止位

·XonChar: 指明发送和接收的XON字符值,它表明允许继续传输。

·XoffChar: 指明发送和接收的XOFF字符值,它表示暂停数据传输。

·ErrorChar: 本字符用来代替接收到的奇偶校验发生错误的字符。

·EofChar: 用来表示数据的结束。

·EvtChar: 事件字符。当接收到此字符的时候,会产生一个事件。

·wReserved1: 保留的位,没有使用。

如果GetCommState()函数调用成功,则返回值不为零。若函数调用失败,则返回值为零,如果想得到进一步的错误信息,可以调用GetLastError()函数来获取。

GetLastError()函数也是Win32API函数,它的声明如下:

DWORD GetLastError(VOID);

如果应用程序只需要修改一部分配置的时候,可以通过GetCommState()函数获得当前的DCB结构,然后更改DCB结构中的参数,调用SetCommState()函数配置修改过的DCB来配置端口。SetCommState()函数声明如下:

BOOL SetCommState (

HANDLE hFile, // 已打开的串口的句柄

LPDCB lpDCB  // 指向DCB结构的指针

);

SetCommState()函数的第一参数hFile是由CreateFile()函数返回的已打开的串口的句柄,第二个参数也是指向DCB结构的。如果函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。出错时可以调用GetLastError()函数获得进一步的出错信息。SetCommState()函数调用的DCB结构中的XonChar等价于XoffChar成员,则SetCommState()函数会调用失败。

DCB最经常改变的参数是数据传输速率、奇偶校验的方法以及数据位和停止位数。Windows为改变这些设置提供了BuildCommDCB函数,函数声明如下:

BOOL BuildCommDCB(

  LPCTSTR lpDef,  // 设置的字符串

  LPDCB lpDCB    // 指向DCB结构的指针

);

BuildCommDCB()参数包含新设置的字符串和一个DCB结构的参数,该设置将提供给DCB结构。新设置的字符串与DOS系统或者Windows NT/2000系统中的Mode命令格式相同。如:

baud=1200 parity=N data=8 stop=1

这条语句将数据传输速率设置为1200bits/s,关闭奇偶校验,数据位数设为8,停止位数设为1。与在DOS或Windows NT/2000系统中一样,该字符串不包括串口的名称,实际上这个函数并不改变端口的设置,因此没有必要标识该串口,当然这个串口必须是有效的串口。新的设置只是简单地拷贝到已提供好的DCB结构中,要使新设置生效,还必须调用SetCommState()函数。BuildCommDCB()支持老的和新的各种版本的Mode命令,缺省情况下,BuildCommDCB()函数禁止XON/XOFF和硬件流的控制。如果使用硬件流控制,则必须设置DCB结构的各个成员的值。如果这个函数调用成功,则返回值不为零。如果想得到进一步的错误信息,可以调用GetLastError()函数来获取。

2.  缓冲区控制

Win32通信API除了提供SetupComm()函数实现初始化的缓冲区控制外,还提供了PurgeComm()函数和FlushFileBuffers()函数来进行缓冲区操作。

PurgeComm()函数的声明如下:

BOOL PurgeComm(

 HANDLE hFile,  // 返回的句柄

 DWORD dwFlags  // 执行的动作

);

参数hFile指向由CreateFile函数返回的句柄,dwFlags表示执行的动作,这个参数可以是表表5中的任一个。参数hFile指向由CreateFile函数返回的句柄,可以调用GetLastError()函数获得进一步的错误信息。

表5                          停止位数和奇偶校验位

             值

               描述

    PURGE_TXABORT

即使发送操作没有完成,也终止所有的重叠发送操作,立即返回

    PURGE_RXABORT

即使接收操作没有完成,也终止所有的重叠接收操作,立即返回

    PURGE_TXCLEAR

清除发送缓冲区

    PURGE_RXCLEAR

清除接收缓冲区

由上面的叙述可以看出,PurgeComm()函数可以在读写操作的同时,清空缓冲区。当应用程序在读写操作时调用PurgeComm()函数,不能保证缓冲区内的所有字符都被发送。如果要保证缓冲区的所有字符都被发送,应该调用FlushFileBuffer()函数。该函数只受流量控制的支配,不受超时控制的支配,它在所有的写操作完成后才返回。

FlushFileBuffers()的函数声明如下:

BOOL FlushFileBuffers(

 HANDLE hFile  // 函数打开的句柄

);

参数hFile指向由CreateFile函数打开的句柄,如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。出错时可以调用GetLastError()函数获得进一步的出错信息。

 

2.3   读写串口

利用Win32通信API读写串口时,既可以同步执行,也可以重叠(异步)执行。在同步执行时,函数直到操作完成后才返回。这意味着在同步执行时线程会被阻塞,从而导致效率降低。在重叠执行时,即使操作还未完成,调用的函数也会立即返回。费时的I/O操作在后台进行,这样线程就可以做其它工作。例如,线程可以在不同的句柄上同时执行I/O操作,甚至可以在同一句柄上同时进行读写操作。“重叠”一词的含义就在于此。

1.  读串口操作

程序可以使用Win32API ReadFile()函数或者ReadFileEx()函数从串口中读取数据。ReadFile()函数对同步或异步操作都支持,而ReadFileEx()只支持异步操作。这两个函数都受到函数是否异步操作、超时操作等有关参数的影响和限定。

ReadFile()函数声明如下:

BOOL ReadFile(

  HANDLE hFile,      // 指向标识的句柄

  LPVOID lpBuffer,    // 指向一个缓冲区

  DWORD nNumberOfBytesToRead, // 读取的字节数

  LPDWORD lpNumberOfBytesRead, // 指向调用该函数读出的字节数

  LPOVERLAPPED lpOverlapped   // 一个OVERLAPPED的结构

);

其中主要参数介绍如下:

·hFile:指向标识的句柄。对串口来说,就是由CreateFile函数返回的句柄。该句柄必须拥有GENERIC_READ的权限。

·lpBuffer:指向一个缓冲区,该缓冲区主要用来存放从串口设备中读取的数据。

·nNumberOfBytesToRead:指定要从串口设备读取的字节数。

·lpNumberOfBytesRead:指向调用该函数读出的字节数。ReadFile()在读操作前,首先将其设置为0。Windows NT/2000中当lpOverlapped没有设置时,lpNumberOfBytesRead必须设置。当lpOverlapped设置时,lpNumberOfBytesRead可以不设置。这是可以调用GetOverlappedResult()函数获取实际的读取数值。Windows 9x中这个参数一定要设置。

·lpOverlapped:是一个OVERLAPPED的结构,该结构将在后面介绍。如果hFile以FILE_FLAG_OVERLAPPED方式常见,则需要此结构;否则,不需要此结构。

需要注意的是如果该函数因为超时而返回,那么返回值是TRUE。参数lpOverlapped 在操作时应该指向一个OVERLAPPED的结构,如果该参数为NULL ,那么函数将进行同步操作,而不管句柄是否是由FILE_FLAG_OVERLAPPED 标志建立的。当ReadFile 返回FALSE时,不一定就是操作失败,线程应该调用GetLastError函数分析返回的结果。例如,在重叠操作时如果操作还未完成函数返回,那么函数就返回FALSE,而且GetLastError函数返回ERROR_IO_PENDING。

2.  写串口操作

可以使用Win32API函数WriteFile() 或者WriteFileEx()向串口中写数据。WriteFile()函数对同步或异步操作都支持,而WriteFileEx()只支持异步操作。这两个函数都受到函数是否异步操作、超时操作等有关参数的影响和限定。

WriteFile()函数声明如下:

BOOL WriteFile(

HANDLE hFile,      // 指向标识的句柄

  LPCVOID lpBuffer,    // 指向一个缓冲区

  DWORD nNumberOfBytesToWrite, // 指定要向串口设备写入的字节数

  LPDWORD lpNumberOfBytesWritten, // 指向调用该函数已写入的字节数

  LPOVERLAPPED lpOverlapped   // 一个OVERLAPPED的结构

);

其中主要参数介绍如下:

·hFile:指向标识的句柄。对串口来说,就是由CreateFile函数返回的句柄。该句柄必须拥有GENERIC_WRITE的权限。

·lpBuffer:指向一个缓冲区,该缓冲区主要用来存放待写入串口设备的数据。

·nNumberOfBytesToWrite:指定要向串口设备写入的字节数。

·lpNumberOfBytesWritten:指向调用该函数已写入的字节数。WriteFile()在写操作前,首先将其设置为0。Windows NT/2000中当lpOverlapped没有设置时,lpNumberOfBytesWritten必须设置。当lpOverlapped设置时,lpNumberOfBytesWritten可以不设置。这是可以调用GetOverlappedResult()函数获取实际的读取数值。Windows 9x中这个参数一定要设置。

·lpOverlapped:是一个OVERLAPPED的结构,该结构将在后面介绍。如果hFile以FILE_FLAG_OVERLAPPED方式常见,则需要此结构;否则,不需要此结构。

如果函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

3.  异步I/O操作

异步(重叠)I/O操作是指应用程序可以在后台读或者写数据,而在前台做其它事情,例如,用程序可以在开始时对10000个数据进行读或写操作,然后返回执行其它的操作;在读写完成后,Windows就会产生一个信号,应用程序得到这个信号,便可以进行其它的读写操作。

要使用OVERLAPPED的结构,CreateFile()函数的dwFlagsAndAttributes参数必须设为FILE_FLAG_OVERLAPPED标识,读写串口函数必须指定OVERLAPPED结构。异步I/O操作在Windows中使用广泛。

OVERLAPPED结构类型声明如下:

typedef struct_OVERLAPPED { // 0

   DWORD Internal;

   DWORD InteralHigh;

   DWORD Offset;

   DWORD OffsetHigh;

   HANDLE hEvent;

} OVERLAPPED;

其中主要参数如下:

·Internal:操作系统保留,指出一个和系统相关的状态。当GetOverlappedResult()函数返回时,如果将扩展信息设置为ERROR_IO_PENDING,该参数有效。

·InteralHigh:操作系统保留,指出发送或接收的数据长度,当GetOverlappedResult()函数返回值不为0时,该参数有效。

·Offset和OffsetHigh:指明文件传送的开始位置和字节偏移量的高位字。当进行端口操作时,这两个参数被忽略。

 ·hEvent:指定一个I/O操作完成后触发的事件(信号)。在调用读写函数进行I/O操作之前,必须设置该参数。

在设置了异步I/O操作后,I/O操作和函数返回有以下两种情况:

1 函数返回时I/O操作已经完成:此时结果好像是同步执行的,但实际上这是异步执行的结果。

2 函数返回时I/O操作还没完成:此时一方面,函数返回值为零,并且GetLastError()函数返回ERROR_IO_PENDING;另一方面,系统把OVERLAPPED中的信号事件设为无信号状态。当I/O操作完成时,系统要把它设置为信号状态。

异步I/O操作可以由GetOverlappedResult()函数来获取结果,也可以使用Windows信号函数来处理。GetOverlappedResult()函数可声明为:

BOOL GetOverlappedResult(

  HANDLE hFile,

  LPOVERLAPPED lpOverlapped,

  LPDWORD lpNumberOfBytesTransferred,

  BOOL bWait

);

其中主要参数介绍如下:

·hFile:标识通信句柄,它应该和开始调用重叠结构的ReadFile、WriteFile、WaitCommEvent函数的参数一致。

·lpOverlapped:在启动异步操作时指定的OVERLAPPED结构。

·lpNumberOfBytesTransferred:指向一个长整型变量,该变量接收有一个读或写操作实际传递的字节数。

·bWait:指定函数是否等待挂起的异步操作完成。如果该参数设为1,则该函数知道操作完成后才返回。如果该参数被设为0,同时处于被挂起状态,则该函数返回为0,并且GetLastError函数返回ERROR_IO_INCOMPLETE。

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

Windows也使用等待函数来检查事件对象的当前状态或等待Windows状态信号,在WaitForSingleObject()函数, WaitForSingleObjectEx()函数,以及WaitForMultipleObject() ,WaitForMultipleObjectsEx() 函数中指定OVERLAPPED结构中的 hEvent,即可获取函数返回事件。

4.  超时设置

Windows 9x/NT/2000中读写串口引入了超时结构。超时结构直接影响读和写的操作行为。当事先设定的超时间隔消逝时,ReadFile() 、ReadFileEx()、 WriteFile()和 WriteFileEx()操作仍未结束,那么超时设置将无条件结束读写操作,而不管是否已读出或已写入指定数量的字符。

在读或写操作期间发生的超时将不按错误处理,即读或写操作返回指定成功的值。对于同步读或写操作,实际传输的字节数由ReadFile()和Write()函数报告。对于异步操作,则有OVERLAPPED结构来获取。

超时结构定义如下:

typedef struct_COMMTIMEOUTS {

    DWORD ReadIntervalTimeout;

    DWORD ReadTotalTimeoutMultiplier;

    DWORD ReadTotalTimeoutConstant;

DWORD WriteTotalTimeoutMultiplier;

DWORD WriteTotalTimeoutConstant;

} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

其中主要参数如下:

·ReadIntervalTimeout:以ms为单位指定通信线路上两个字符到达之间的最大时间间隔。在ReadFile()操作期间,从接收到第一个字符时开始计时。如果任意两个字符到达之间的时间间隔超过这个最大值,则ReadFile()操作完成,并返回缓冲数据。如果被置为0,则表示不使用间隔超时。

·ReadTotalTimeoutMultiplier:以ms为单位指定一个系数,该系数用来计算读操作的总超时时间。

·ReadTotalTimeoutConstant:以ms为单位指定一个常数,该常数也用来计算读操作的总超时时间。

·WriteTotalTimeoutMultiplier:以ms为单位指定一个系数,该系数用来计算写操作的总超时时间。

·WriteTotalTimeoutConstant:以ms为单位指定一个常数,该常数也用来计算写操作的总超时时间。

超时有两种类型。第一种类型叫区间超时(interval timeout),它仅适应于从端口读取数据。它指定在读取两个字符之间要经历多长时间。接收一个字符时,Windows就启动一个内部计时器。在下一个字符到达之前,如果定时器超过了区间超时设定时间,读函数就会放弃。第二种类型的超时叫做总超时( total timeout),它适于读和写端口。当读或写特定字节数需要的总时间超过某一阈值时,该超时即被触发。

Windows使用下面的式子计算总超时时间:

ReadTotalTimeout=( ReadTotalTimeoutMultiplier*bytes_to_read )+ ReadTotalTimeoutConstant;

WriteTotalTimeout=( WriteTotalTimeoutMultiplier*bytes_to_write )+ WriteTotalTimeoutConstant;

该方程使总超时时间成为灵活的工具。总超时时间不是固定值,而是根据读或写的字节数而“漂浮不定”。应用程序通过设置系数为0而只是用常数,和通过设置常数为0而只使用于系数。如果系数和常数都为0,则没有总超时时间。

因此每个读操作的总超时时间等于ReadTotalTimeoutMultiplier参数值乘以读操作要读取的字节数再加上ReadTotalTimeoutConstant参数值的和。如果将ReadTotalTimeoutMultiplier和ReadTotalTimeoutConstant都设置为0,则表示读操作不使用总超时时间。每个读间隔超时参数ReadIntervalTimeout被设置为MAXDWORK,而且两个读总超时参数都被设置为0,那么标识只要一读完接收缓冲区而不管得到什么字符就完成读操作,即使它是空的。当接收中有间隔时,间隔超时将迫使读操作返回。因此使用间隔超时的进程可以设置一个非常短的间隔超时参数,这样它可以实现对一个或一些字符的小的、孤立的数据作出反应。

每个写操作的WriteTotalTimeoutConstant等于WriteTotalTimeoutMultiplier成员值乘以写操作要写的字节数,再加上WriteTotalTimeoutConstant参数值的和。如果WriteTotalTimeoutMultiplier和WriteTotalTimeoutConstant参数值都设置为0则表示写操作不使用WriteTotalTimeoutConstant。

在传输某种流量控制被阻塞时和调用SetCommBreak()函数把字符挂起,写操作的超时可能有用。如果所有的读超时参数都为0,即没有使用读超时,那么读操作知道读完要求的字节数或发生错误时位置。同样,如果所有的写超时参数都为0,那么写操作知道要求的字节数或发生错误时为止。当打开通信资源时,超时参数将根据上次设备被打开时所设置的值设置。如果资源从未打开或调用SetComm函数,那么所有的超时参数都设置为0。

如果欲获得当前超时参数,应用程序可以调用GetCommTimeouts()函数。该函数声明如下:

BOOL GetCommTimeouts(

  HANDLE hFile,

  LPCOMMTIMEOUTS lpCommTimeouts

);

其中主要参数如下:

·hFile:标识通信设备,CreateFile()函数返回该句柄;

·lpCommTimeouts:指向一个CommTIMEOUTS结构,返回超时信息。

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

如果要设置或改变原来的超时参数,应用程序可以调用SetCommTimeouts()函数。该函数声明如下:

BOOL SetCommTimeouts(

  HANDLE hFile,

  LPCOMMTIMEOUTS lpCommTimeouts

);

其中主要参数如下:

·hFile:标识通信设备,CreateFile()函数返回该句柄;

·lpCommTimeouts:指向一个CommTIMEOUTS结构,返回超时信息。

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

5.  通信状态和通信错误

如果在串口通信中发生错误,如发生中断,奇偶错误等,I/O操作将会终止。如果程序要进一步执行I/O操作,必须调用ClearCommError()函数。ClearCommError()函数有两个作用:第一个作用是清除错误条件;第二个作用是确定串口通信状态。ClearCommError()函数的声明如下:

BOOL ClearCommError(

   HANDLE hFile,

   LPDWORD lpErrors,

   LPCOMSTAT lpStat

);

其中主要参数介绍如下:

·hFile :标识通信设备,CreateFile()函数返回该句柄。

·lpErrors:指向用一个指明错误类型的掩码填充的32位变量。该参数可以是表6中各值的组合。

·lpStat:指向一个COMSTAT结构,该结构接收设备的状态信息。如果lpStat参数不设置,则没有设备状态信息被返回。

表6                             通信错误列表

              值

              描述

      CE_BREAK

硬件检测到一个中断条件

      CE_FRAME

硬件检测到一个帧出错

      CE_IOE

发生I/O错误

      CE_MODE

模式出错,或者是句柄无效

      CE_OVERRUN

超速错误

      CE_RXOVER

接收缓冲区超限,或者是输入缓冲区中没有空间,或者实在文件结束符(EOF)接收后接收到一个字符

      CE_RXPARITY

奇偶校验错误

      CE_TXFULL

发送缓冲区满

      CE_DNS

没有检测到并行设备

      CE_OOP

并行设备缺纸

      CE_PTO

并行设备发生超时错误

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。在同步操作时,可以调用ClearCommError()函数来确定串口的接收缓冲区处于等待状态的字节数,而后可以使用ReadFile()或者WriteFile()函数一次读写完。

COMSTAT结构存放有关通信设备的当前信息。该结构内容由ClearCommError()函数填写。COMSTAT结构声明如下:

typedef struct_COMSTAT(

    DWORD fCtsHold: 1;

    DWORD fDsrHold: 1;

    DWORD fRlsdHold: 1;

    DWORD fXoffSent: 1;

    DWORD fEof: 1;

    DWORD fTxim: 1;

    DWORD fReserved: 25;

    DWORD cbInQue;

    DWORD cbOutQue;

} COMSTAT,*LPCOMSTAT;

其中主要参数介绍如下:

·fCtsHold:指明是否等待CRS信号,如果为1,则发送等待。

·fDsrHold:指明是否等到DRS信号,如果为1,则发送等待。

·fRlsdHold:指明是否等待RLSD信号,如果为1,则发送等待。

·fXoffSent:指明收到XOFF字符后发送是否等待。如果为1,则发送等待。如果把XOFF字符发送给一系统时,该系统就把下一个字符当成XON,而不管实际字符是什么,此时发送将停止。

·fEof:EOF字符送出。

·fTxim:指明字符是否正等待被发送,如果为1,则字符正等待被发送。

·fReserved:系统保留。

·cbInQue:指明串行设备接收到的字节数。并不是指ReadFile操作要求读的字节数。

·cbOutQue:指明发送缓冲区尚未发送的字节数。如果进行不重叠写操作时值为0。

 

2.4   通信事件

Windows进程中监视发生在通信资源中的一组事件,这样应用程序可以不检查端口状态就可以知道某些条件何时发生,这将是非常有用的。通过使用事件,应用程序不需要为接收字节而连续不断地检测端口,从而节省CPU时间。

1.  通信事件

Windows可以利用GetCommMask()函数和 SetCommMask函数来控制表7所示的通信事件。

表7                         Windows通信事件列表

                值

            描述

     EV_BREAK

检测到输入的终止

     EV_CTS

CTS(清除发送)信号改变状态

     EV_DSR

DSR(数据设置就绪)信号改变状态

     EV_ERR

发生了线路状态错误,线路状态错误时CE_FRAME(帧错误)、CE_OVERRUN (接收缓冲区超限)和CE_RXPARITY(奇偶校验错误)

     EV_RING

检测到振铃

     EV_RLSD

RLSD(接收到线路信号检测)信号改变状态

    EV_RXCHAR

接收到一个字符,并放入输入缓冲区

    EV_RXFLAG

接收到事件字符(DCB结构地EvtChar成员),并放入输入缓冲区

    EV_TXEMPTY

输出缓冲区中最后一个字符发送出去

 

2.  操作通信事件

应用程序可以利用SetCommMask()函数简历事件掩模来监视指定通信资源上的事件。SetCommMask函数的声明如下:

BOOL SetCommMask(

   HANDLE hFile,

   DWORD dwEvtMask

);

其中主要参数介绍如下:

·hFile :标识通信设备,CreateFile()函数返回该句柄。

·dwEvtMask:事件掩模,标识将被监视的通信事件。如果该参数设置为0,则表示禁止所有事件。如果不为0,则可以是表7中各种事件的组合。

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

如果想获取特定通信资源的当前事件掩模,可以使用GetCommMask()函数。GetCommMask()函数声明如下:

BOOL GetCommMask(

   HANDLE hFile,

   LPDWORD lpEvtMask

);

其中主要参数介绍如下:

·hFile :标识通信设备,CreateFile()函数返回该句柄。

·dwEvtMask:事件掩模,标识将被监视的通信事件,一个32位变量,可以是表7中各种事件的组合。

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

3.  监视通信事件

在用SetCommMask()指定了有用的事件后,应用程序就调用WaitCommEvent()函数来等待其中一个事件发生。WaitCommEvent()函数既可以同步使用,也可以异步使用。WaitCommEvent()函数声明如下:

BOOL WaitCommEvent(

   HANDLE hFile,

   LPDWORD lpEvtMask,

   LPOVERLAPPED lpOverlapped,

);

其中主要参数介绍如下:

·hFile :标识通信设备,CreateFile()函数返回该句柄。

·dwEvtMask:指向一个32位变量,接收事件掩模,标识所发生的通信事件属于何种类型。可以是表7中各种事件的组合。

·lpOverlapped:指向一个OVERLAPPED结构,如果打开hFile表示的通信设备时,指定FILE_FLAG_OVERLAPPED标志,则该参数被忽略。如果不需要异步操作,则这个参数不用设置。

如果该函数调用成功,则返回值不为零;若函数调用失败,则返回值为零。调用GetLastError()函数可以获得进一步的出错信息。

如果lpOverlapped参数不设置或打开hFile标识的通信设备是未指定FILE_FLAG_OVERLAPPED标志,则知道发生了指定时间或出错时,WaitCommEvent()函数才返回。如果lpOverlapped参数指向一个OVERLAPPED结构,并且打开hFile标识的通信设备时指定了FILE_FLAG_OVERLAPPED标志,则WaitCommEvent()函数以异步操作实现。这种情况下,OVERLAPPED结构中必须含有一个人工复位事件的句柄。和所有异步函数一样,如果异步操作不能立即实现,则该函数返回0,并且GetLastError()函数返回ERROR_IO_PENDING,以指示该操作正在后台进行。此时WaitCommEvent()函数返回之前,系统将OVERLAPPED结构中的hEvent参数设置为无信号状态;当发生了指定时间或出错时,系统将其设置为有信号状态。调用程序可使用等待函数确定事件对象的状态,然后使用GetOverlappedResult()函数确定WaitCommEvent()函数的操作结束。GetOverlappedResult()函数报告该操作成功或者失败,并且lpEvtMask()函数所指向的变量被设置以指示所发生的事件。

如果一个进程在WaitCommEvent()函数操作进行期间使用SetCommMask()函数将立即返回,并且由EvtMask参数指向的变量被设置。

注意:WaitCommEvent()只检测发生在等待开始后的事件。例如,如果指定EV_RXCHAR事件,则只有当收到函数字符并将字符放进接收缓冲区后才能满足等待条件。WaitCommEvent()调用时已在接收缓冲区中的字符不符合等待条件。监视CTS、DSR等信号状态改变的事件时,WaitCommEvent()函数只报告信号的变动,但不报告当前的信号状态,如果要查询这些信号状态,进程可以调用GetCommModemstatus()函数。


************************************************************************************************************

用Windows API进行串口编程的一般步骤及相关函数讲解

虽然使用诸如 CSerialPort VC串口类,MSComm VC 串口控件等非常方便,但有时这些控件并不适合自己的特殊需求,所以有必要了解一下基于Windows API的串口编程方法,下面介绍一下API串口编程的一般步骤及相关串口API函数。

串口操作一般有四步,分别是:

1) 打开串口
2) 配置串口
3) 读写串口
4) 关闭串口

1、 打开串口

  在《VC 打开串口》一文中我们已经单独介绍过如果利用API打开串口的方法,打开串口是用API函数CreateFile来打开或创建的。该函数的原型为: 

  1. HANDLE CreateFile( LPCTSTR lpFileName,  
  2.                   DWORD dwDesiredAccess,  
  3.                   DWORD dwShareMode,  
  4.                   LPSECURITY_ATTRIBUTES lpSecurityAttributes,  
  5.                   DWORD dwCreationDistribution,  
  6. DWORD dwFlagsAndAttributes,  
  7. HANDLE hTemplateFile);  

 

参数详解:

  • lpFileName:将要打开的串口逻辑名,如“COM1”;
  • dwDesiredAccess:指定串口访问的类型,可以是读取、写入或二者并列;
  • dwShareMode:指定共享属性,由于串口不能共享,该参数必须置为0;
  • lpSecurityAttributes:引用安全性属性结构,缺省值为NULL;
  • dwCreationDistribution:创建标志,对串口操作该参数必须置为OPEN_EXISTING;
  • dwFlagsAndAttributes:属性描述,用于指定该串口是否进行异步操作,该值为FILE_FLAG_OVERLAPPED,表示使用异步的I/O;该值为0,表示同步I/O操作;
  • hTemplateFile:对串口而言该参数必须置为NULL;

  串口的操作可以有两种操作方式:同步操作方式和重叠操作方式(也称为异步操作方式)。同步操作时,API函数会阻塞直到操作完成以后才能返回(在多线程方式中,虽然不会阻塞主线程,但是仍然会阻塞监听线程);而重叠操作方式,API函数会立即返回,操作在后台进行,避免线程的阻塞。

同步I/O方式打开串口的示例:

  1. HANDLE hCom;  //全局变量,串口句柄  
  2. hCom=CreateFile("COM1",//COM1口  
  3.     GENERIC_READ|GENERIC_WRITE, //允许读和写  
  4.     0, //独占方式  
  5.     NULL,  
  6.     OPEN_EXISTING, //打开而不是创建  
  7.     0, //同步方式  
  8.     NULL);  
  9. if(hCom==(HANDLE)-1)  
  10. {  
  11.     AfxMessageBox("打开COM失败!");  
  12.     return FALSE;  
  13. }  
  14. return TRUE; 

重叠I/O打开串口的示例:

  1. HANDLE hCom;  //全局变量,串口句柄  
  2. hCom =CreateFile("COM1",  //COM1口  
  3.             GENERIC_READ|GENERIC_WRITE, //允许读和写  
  4.             0,  //独占方式  
  5.             NULL,  
  6.             OPEN_EXISTING,  //打开而不是创建  
  7.             FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式  
  8.             NULL);  
  9. if(hCom ==INVALID_HANDLE_VALUE)  
  10. {  
  11.     AfxMessageBox("打开COM失败!");  
  12.     return FALSE;  
  13. }  
  14.    return TRUE;  

2、配置串口

  在打开通讯设备句柄后,常常需要对串口进行一些初始化配置工作。这需要通过一个DCB结构来进行。DCB结构包含了诸如波特率、数据位数、奇偶校验和停止位数等信息。在查询或配置串口的属性时,都要用DCB结构来作为缓冲区。
  一般用CreateFile打开串口后,可以调用GetCommState函数来获取串口的初始配置。要修改串口的配置,应该先修改DCB结构,然后再调用SetCommState函数设置串口。
  DCB结构包含了串口的各项参数设置,下面仅介绍几个该结构常用的变量:

 

  1. typedef struct _DCB{  
  2.    ………  
  3.    //波特率,指定通信设备的传输速率。这个成员可以是实际波特率值或者下面的常量值之一:  
  4.    DWORD BaudRate;   
  5. CBR_110,CBR_300,CBR_600,CBR_1200,CBR_2400,CBR_4800,CBR_9600,CBR_19200, CBR_38400,   
  6. CBR_56000, CBR_57600, CBR_115200, CBR_128000, CBR_256000, CBR_14400  
  7.  
  8. DWORD fParity; // 指定奇偶校验使能。若此成员为1,允许奇偶校验检查   
  9.    …  
  10. BYTE ByteSize; // 通信字节位数,4—8  
  11. BYTE Parity; //指定奇偶校验方法。此成员可以有下列值:  
  12. EVENPARITY 偶校验     NOPARITY 无校验  
  13. MARKPARITY 标记校验   ODDPARITY 奇校验  
  14. BYTE StopBits; //指定停止位的位数。此成员可以有下列值:  
  15. ONESTOPBIT 1位停止位   TWOSTOPBITS 2位停止位  
  16. ONE5STOPBITS   1.5位停止位  
  17.    ………  
  18.   } DCB;  
  19. winbase.h文件中定义了以上用到的常量。如下:  
  20. #define NOPARITY            0  
  21. #define ODDPARITY           1  
  22. #define EVENPARITY          2  
  23. #define ONESTOPBIT          0  
  24. #define ONE5STOPBITS        1  
  25. #define TWOSTOPBITS         2  
  26. #define CBR_110             110  
  27. #define CBR_300             300  
  28. #define CBR_600             600  
  29. #define CBR_1200            1200  
  30. #define CBR_2400            2400  
  31. #define CBR_4800            4800  
  32. #define CBR_9600            9600  
  33. #define CBR_14400           14400  
  34. #define CBR_19200           19200  
  35. #define CBR_38400           38400  
  36. #define CBR_56000           56000  
  37. #define CBR_57600           57600  
  38. #define CBR_115200          115200  
  39. #define CBR_128000          128000  
  40. #define CBR_256000          256000  

GetCommState函数可以获得COM口的设备控制块,从而获得相关参数:

  1. BOOL GetCommState(  
  2.    HANDLE hFile, //标识通讯端口的句柄  
  3.    LPDCB lpDCB //指向一个设备控制块(DCB结构)的指针  
  4.   );  
  5. SetCommState函数设置COM口的设备控制块:  
  6. BOOL SetCommState(  
  7.    HANDLE hFile,   
  8.    LPDCB lpDCB   
  9.   );  

  除了在BCD中的设置外,程序一般还需要设置I/O缓冲区的大小和超时。Windows用I/O缓冲区来暂存串口输入和输出的数据。如果通信的速率较高,则应该设置较大的缓冲区。调用SetupComm函数可以设置串行口的输入和输出缓冲区的大小。

  1. BOOL SetupComm(  
  2.  
  3.     HANDLE hFile,   // 通信设备的句柄   
  4.     DWORD dwInQueue,    // 输入缓冲区的大小(字节数)   
  5.     DWORD dwOutQueue    // 输出缓冲区的大小(字节数)  
  6.    );  

  在用ReadFile和WriteFile读写串行口时,需要考虑超时问题。超时的作用是在指定的时间内没有读入或发送指定数量的字符,ReadFile或WriteFile的操作仍然会结束。
  要查询当前的超时设置应调用GetCommTimeouts函数,该函数会填充一个COMMTIMEOUTS结构。调用SetCommTimeouts可以用某一个COMMTIMEOUTS结构的内容来设置超时。
  读写串口的超时有两种:间隔超时和总超时。间隔超时是指在接收时两个字符之间的最大时延。总超时是指读写操作总共花费的最大时间。写操作只支持总超时,而读操作两种超时均支持。用COMMTIMEOUTS结构可以规定读写操作的超时。
COMMTIMEOUTS结构的定义为:

  1. typedef struct _COMMTIMEOUTS {     
  2.     DWORD ReadIntervalTimeout; //读间隔超时  
  3.     DWORD ReadTotalTimeoutMultiplier; //读时间系数  
  4.     DWORD ReadTotalTimeoutConstant; //读时间常量  
  5.     DWORD WriteTotalTimeoutMultiplier; // 写时间系数  
  6.     DWORD WriteTotalTimeoutConstant; //写时间常量  
  7. } COMMTIMEOUTS,*LPCOMMTIMEOUTS;  

COMMTIMEOUTS结构的成员都以毫秒为单位。总超时的计算公式是:
总超时=时间系数×要求读/写的字符数+时间常量 
例如,要读入10个字符,那么读操作的总超时的计算公式为:
读总超时=ReadTotalTimeoutMultiplier×10+ReadTotalTimeoutConstant 
可以看出:间隔超时和总超时的设置是不相关的,这可以方便通信程序灵活地设置各种超时。 

如果所有写超时参数均为0,那么就不使用写超时。如果ReadIntervalTimeout为0,那么就不使用读间隔超时。如果ReadTotalTimeoutMultiplier 和 ReadTotalTimeoutConstant 都为0,则不使用读总超时。如果读间隔超时被设置成MAXDWORD并且读时间系数和读时间常量都为0,那么在读一次输入缓冲区的内容后读操作就立即返回,而不管是否读入了要求的字符。
  在用重叠方式读写串口时,虽然ReadFile和WriteFile在完成操作以前就可能返回,但超时仍然是起作用的。在这种情况下,超时规定的是操作的完成时间,而不是ReadFile和WriteFile的返回时间。
配置串口的示例代码:

 

  1. SetupComm(hCom,1024,1024); //输入缓冲区和输出缓冲区的大小都是1024  
  2.  
  3. COMMTIMEOUTS TimeOuts;  
  4. //设定读超时  
  5. TimeOuts.ReadIntervalTimeout=1000;  
  6. TimeOuts.ReadTotalTimeoutMultiplier=500;  
  7. TimeOuts.ReadTotalTimeoutConstant=5000;  
  8. //设定写超时  
  9. TimeOuts.WriteTotalTimeoutMultiplier=500;  
  10. TimeOuts.WriteTotalTimeoutConstant=2000;  
  11. SetCommTimeouts(hCom,&TimeOuts); //设置超时  
  12.  
  13. DCB dcb;  
  14. GetCommState(hCom,&dcb);  
  15. dcb.BaudRate=9600; //波特率为9600  
  16. dcb.ByteSize=8; //每个字节有8位  
  17. dcb.Parity=NOPARITY; //无奇偶校验位  
  18. dcb.StopBits=TWOSTOPBITS; //两个停止位  
  19. SetCommState(hCom,&dcb);  
  20.  
  21. PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);  

在读写串口之前,还要用PurgeComm()函数清空缓冲区,该函数原型:

 

  1. BOOL PurgeComm(  
  2.  
  3.     HANDLE hFile,   //串口句柄  
  4.     DWORD dwFlags   // 需要完成的操作  
  5.    );    

参数dwFlags指定要完成的操作,可以是下列值的组合:

  1. PURGE_TXABORT     中断所有写操作并立即返回,即使写操作还没有完成。  
  2. PURGE_RXABORT     中断所有读操作并立即返回,即使读操作还没有完成。  
  3. PURGE_TXCLEAR     清除输出缓冲区  
  4. PURGE_RXCLEAR     清除输入缓冲区  

3、读写串口

我们使用ReadFile和WriteFile读写串口,下面是两个函数的声明:

 

  1. BOOL ReadFile(  
  2.  
  3.     HANDLE hFile,   //串口的句柄  
  4.       
  5.     // 读入的数据存储的地址,  
  6.     // 即读入的数据将存储在以该指针的值为首地址的一片内存区  
  7.     LPVOID lpBuffer,      
  8.     DWORD nNumberOfBytesToRead, // 要读入的数据的字节数  
  9.       
  10.     // 指向一个DWORD数值,该数值返回读操作实际读入的字节数  
  11.     LPDWORD lpNumberOfBytesRead,      
  12.       
  13.     // 重叠操作时,该参数指向一个OVERLAPPED结构,同步操作时,该参数为NULL。  
  14.     LPOVERLAPPED lpOverlapped     
  15.    );     
  16. BOOL WriteFile(  
  17.  
  18.     HANDLE hFile,   //串口的句柄  
  19.       
  20.     // 写入的数据存储的地址,  
  21.     // 即以该指针的值为首地址的nNumberOfBytesToWrite  
  22.     // 个字节的数据将要写入串口的发送数据缓冲区。  
  23.     LPCVOID lpBuffer,     
  24.       
  25.     DWORD nNumberOfBytesToWrite,    //要写入的数据的字节数  
  26.       
  27.     // 指向指向一个DWORD数值,该数值返回实际写入的字节数  
  28.     LPDWORD lpNumberOfBytesWritten,   
  29.       
  30.     // 重叠操作时,该参数指向一个OVERLAPPED结构,  
  31.     // 同步操作时,该参数为NULL。  
  32.     LPOVERLAPPED lpOverlapped     
  33.    );  

  在用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。这说明重叠操作还未完成。

同步方式读写串口比较简单,下面先例举同步方式读写串口的代码:

 

  1. //同步读串口  
  2. char str[100];  
  3. DWORD wCount;//读取的字节数  
  4. BOOL bReadStat;  
  5. bReadStat=ReadFile(hCom,str,100,&wCount,NULL);  
  6. if(!bReadStat)  
  7. {  
  8.     AfxMessageBox("读串口失败!");  
  9.     return FALSE;  
  10. }  
  11. return TRUE;  
  12.  
  13. //同步写串口  
  14.  
  15.     char lpOutBuffer[100];  
  16.     DWORD dwBytesWrite=100;  
  17.     COMSTAT ComStat;  
  18.     DWORD dwErrorFlags;  
  19.     BOOL bWriteStat;  
  20.     ClearCommError(hCom,&dwErrorFlags,&ComStat);  
  21.     bWriteStat=WriteFile(hCom,lpOutBuffer,dwBytesWrite,& dwBytesWrite,NULL);  
  22.     if(!bWriteStat)  
  23.     {  
  24.         AfxMessageBox("写串口失败!");  
  25.     }  
  26.     PurgeComm(hCom, PURGE_TXABORT|  
  27.         PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);  

在重叠操作时,操作还未完成函数就返回。 

  重叠I/O非常灵活,它也可以实现阻塞(例如我们可以设置一定要读取到一个数据才能进行到下一步操作)。有两种方法可以等待操作完成:一种方法是用象WaitForSingleObject这样的等待函数来等待OVERLAPPED结构的hEvent成员;另一种方法是调用GetOverlappedResult函数等待,后面将演示说明。
下面我们先简单说一下OVERLAPPED结构和GetOverlappedResult函数:
OVERLAPPED结构
OVERLAPPED结构包含了重叠I/O的一些信息,定义如下:

  1. typedef struct _OVERLAPPED { // o    
  2.     DWORD  Internal;   
  3.     DWORD  InternalHigh;   
  4.     DWORD  Offset;   
  5.     DWORD  OffsetHigh;   
  6.     HANDLE hEvent;   
  7. } OVERLAPPED;  

  在使用ReadFile和WriteFile重叠操作时,线程需要创建OVERLAPPED结构以供这两个函数使用。线程通过OVERLAPPED结构获得当前的操作状态,该结构最重要的成员是hEvent。hEvent是读写事件。当串口使用异步通讯时,函数返回时操作可能还没有完成,程序可以通过检查该事件得知是否读写完毕。
  当调用ReadFile, WriteFile 函数的时候,该成员会自动被置为无信号状态;当重叠操作完成后,该成员变量会自动被置为有信号状态。

 

  1. GetOverlappedResult函数  
  2. BOOL GetOverlappedResult(  
  3.     HANDLE hFile,   // 串口的句柄    
  4.       
  5.     // 指向重叠操作开始时指定的OVERLAPPED结构  
  6.     LPOVERLAPPED lpOverlapped,    
  7.       
  8.     // 指向一个32位变量,该变量的值返回实际读写操作传输的字节数。  
  9.     LPDWORD lpNumberOfBytesTransferred,   
  10.       
  11.     // 该参数用于指定函数是否一直等到重叠操作结束。  
  12.     // 如果该参数为TRUE,函数直到操作结束才返回。  
  13.     // 如果该参数为FALSE,函数直接返回,这时如果操作没有完成,  
  14.     // 通过调用GetLastError()函数会返回ERROR_IO_INCOMPLETE。  
  15.     BOOL bWait    
  16.    );     

该函数返回重叠操作的结果,用来判断异步操作是否完成,它是通过判断OVERLAPPED结构中的hEvent是否被置位来实现的。

异步读串口的示例代码:

 

  1. char lpInBuffer[1024];  
  2. DWORD dwBytesRead=1024;  
  3. COMSTAT ComStat;  
  4. DWORD dwErrorFlags;  
  5. OVERLAPPED m_osRead;  
  6. memset(&m_osRead,0,sizeof(OVERLAPPED));  
  7. m_osRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);  
  8.  
  9. ClearCommError(hCom,&dwErrorFlags,&ComStat);  
  10. dwBytesRead=min(dwBytesRead,(DWORD)ComStat.cbInQue);  
  11. if(!dwBytesRead)  
  12. return FALSE;  
  13. BOOL bReadStatus;  
  14. bReadStatus=ReadFile(hCom,lpInBuffer,  
  15.                      dwBytesRead,&dwBytesRead,&m_osRead);  
  16.  
  17. if(!bReadStatus) //如果ReadFile函数返回FALSE  
  18. {  
  19.     if(GetLastError()==ERROR_IO_PENDING)  
  20.     //GetLastError()函数返回ERROR_IO_PENDING,表明串口正在进行读操作      
  21.     {  
  22.         WaitForSingleObject(m_osRead.hEvent,2000);  
  23.         //使用WaitForSingleObject函数等待,直到读操作完成或延时已达到2秒钟  
  24.         //当串口读操作进行完毕后,m_osRead的hEvent事件会变为有信号  
  25.         PurgeComm(hCom, PURGE_TXABORT|  
  26.             PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);  
  27.         return dwBytesRead;  
  28.     }  
  29.     return 0;  
  30. }  
  31. PurgeComm(hCom, PURGE_TXABORT|  
  32.           PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);  
  33. return dwBytesRead;  

  对以上代码再作简要说明:在使用ReadFile 函数进行读操作前,应先使用ClearCommError函数清除错误。ClearCommError函数的原型如下:

  1. BOOL ClearCommError(     
  2.     
  3.     HANDLE hFile,   // 串口句柄     
  4.     LPDWORD lpErrors,   // 指向接收错误码的变量     
  5.     LPCOMSTAT lpStat    // 指向通讯状态缓冲区     
  6.    );      

 该函数获得通信错误并报告串口的当前状态,同时,该函数清除串口的错误标志以便继续输入、输出操作。
参数lpStat指向一个COMSTAT结构,该结构返回串口状态信息。 COMSTAT结构 COMSTAT结构包含串口的信息,结构定义如下:

  1. typedef struct _COMSTAT { // cst    
  2.     DWORD fCtsHold : 1;   // Tx waiting for CTS signal   
  3.     DWORD fDsrHold : 1;   // Tx waiting for DSR signal   
  4.     DWORD fRlsdHold : 1;  // Tx waiting for RLSD signal   
  5.     DWORD fXoffHold : 1;  // Tx waiting, XOFF char rec''d   
  6.     DWORD fXoffSent : 1;  // Tx waiting, XOFF char sent   
  7.     DWORD fEof : 1;       // EOF character sent   
  8.     DWORD fTxim : 1;      // character waiting for Tx   
  9.     DWORD fReserved : 25; // reserved   
  10.     DWORD cbInQue;        // bytes in input buffer   
  11.     DWORD cbOutQue;       // bytes in output buffer   
  12. } COMSTAT, *LPCOMSTAT;   

这里只用到了cbInQue成员变量,该成员变量的值代表输入缓冲区的字节数。

  最后用PurgeComm函数清空串口的输入输出缓冲区。

  这段代码用WaitForSingleObject函数来等待OVERLAPPED结构的hEvent成员,下面我们再演示一段调用GetOverlappedResult函数等待的异步读串口示例代码:

 

  1. char lpInBuffer[1024];  
  2. DWORD dwBytesRead=1024;  
  3.     BOOL bReadStatus;  
  4.     DWORD dwErrorFlags;  
  5.     COMSTAT ComStat;  
  6. OVERLAPPED m_osRead;  
  7.  
  8.     ClearCommError(hCom,&dwErrorFlags,&ComStat);  
  9.     if(!ComStat.cbInQue)  
  10.         return 0;  
  11.     dwBytesRead=min(dwBytesRead,(DWORD)ComStat.cbInQue);  
  12.     bReadStatus=ReadFile(hCom, lpInBuffer,dwBytesRead,  
  13.         &dwBytesRead,&m_osRead);  
  14.     if(!bReadStatus) //如果ReadFile函数返回FALSE  
  15.     {  
  16.         if(GetLastError()==ERROR_IO_PENDING)  
  17.         {  
  18.             GetOverlappedResult(hCom,  
  19.                 &m_osRead,&dwBytesRead,TRUE);  
  20.            // GetOverlappedResult函数的最后一个参数设为TRUE,  
  21.            //函数会一直等待,直到读操作完成或由于错误而返回。  
  22.  
  23.             return dwBytesRead;  
  24.         }  
  25.         return 0;  
  26.     }  
  27.     return dwBytesRead;  

异步写串口的示例代码:

 

  1. char buffer[1024];  
  2. DWORD dwBytesWritten=1024;  
  3.     DWORD dwErrorFlags;  
  4.     COMSTAT ComStat;  
  5. OVERLAPPED m_osWrite;  
  6.     BOOL bWriteStat;  
  7.  
  8.     bWriteStat=WriteFile(hCom,buffer,dwBytesWritten,  
  9.         &dwBytesWritten,&m_OsWrite);  
  10.     if(!bWriteStat)  
  11.     {  
  12.         if(GetLastError()==ERROR_IO_PENDING)  
  13.         {  
  14.             WaitForSingleObject(m_osWrite.hEvent,1000);  
  15.             return dwBytesWritten;  
  16.         }  
  17.         return 0;  
  18.     }  
  19.     return dwBytesWritten;  

4、关闭串口

  利用API函数关闭串口非常简单,只需使用CreateFile函数返回的句柄作为参数调用CloseHandle即可:

  1. BOOL CloseHandle(  
  2.     HANDLE hObject; //handle to object to close   
  3. );  

参考文档:http://www.vc-rs232.com/html/VC_SSCOM_Programe/2011/0915/45.html

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:276766次
    • 积分:3810
    • 等级:
    • 排名:第8678名
    • 原创:77篇
    • 转载:222篇
    • 译文:0篇
    • 评论:23条
    最新评论