VC_MFC串口通信编程详解

       在工业控制中,工控机(一般都基于 Windows 平台)经常需要与智能仪表通过串口

进行通信.串口通信方便易行,应用广泛.

  一般情况下,工控机和各智能仪表通过 RS485 总线进行通信.RS485 的通信方式是

半双工的,只能由作为主节点的工控 PC 机依次轮询网络上的各智能控制单元子节点.

每次通信都是由 PC 机通过串口向智能控制单元发布命令,智能控制单元在接收到正

确的命令后作出应答.

  在 Win32下,可以使用两种编程方式实现串口通信,其一是使用 ActiveX控件,这种

方法程序简单,但欠灵活.其二是调用 Windows的 API 函数,这种方法可以清楚地掌握

串口通信的机制,并且自由灵活.下面只介绍 API 串口通信部分.

  串口的操作可以有两种操作方式:同步操作方式和重叠操作方式(又称为异步操作

方式).同步操作时,API 函数会阻塞直到操作完成以后才能返回(在多线程方式中,

虽然不会阻塞主线程,但是仍然会阻塞监听线程);而重叠操作方式,API 函数会立即

返回,操作在后台进行,避免线程的阻塞.

无论哪种操作方式,一般都通过四个步骤来完成:

(1)打开串口

(2)配置串口

(3)读写串口

(4)关闭串口 

 

一 打开串口 

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",// 串口名称

  GENERIC_READ|GENERIC_WRITE,//允许读和写

  0,//独占方式

  NULL,

  OPEN_EXISTING,// 打开而不是创建

  0,//同步方式

  NULL);

if(hCom==(HANDLE)-1)

{

MessageBox("打开 COM 失败!");

return FALSE;

}

return TRUE;

 

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

HANDLE hCom;//全局变量,串口句柄

hCom =CreateFile("COM1",//串口名称

                GENERIC_READ|GENERIC_WRITE,//允许读和写

                0,//独占方式

                NULL,

                OPEN_EXISTING,//打开而不是创建

                FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//重叠方式

                NULL);

if(hCom==INVALID_HANDLE_VALUE)

{

MessageBox("打开 COM 失败!");

return FALSE;

}

return TRUE;

 

二 配置串口 

在打开通讯设备句柄后,常需要对串口进行一些初始化配置工作.这需要通过一个

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   清除输入缓冲区

 

三 读写串口 

使用 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)

{

MessageBox("读串口失败!");

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)

{

MessageBox("写串口失败!");

}

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 {

                            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;

 

四 关闭串口 

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

调用 CloseHandle 即可: 

BOOL CloseHandle(

    HANDLE hObject;//handle to object to close 

);

为了更好地理解串口编程,下面分别编写两个实例,这两个实例都实现了工控机与

百特显示仪表通过 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",// 串口名称

    GENERIC_READ|GENERIC_WRITE,//允许读和写

    0,//独占方式

    NULL,

    OPEN_EXISTING,//打开而不是创建

    0,//同步方式

    NULL);

if(hCom==(HANDLE)-1)

{

MessageBox("打开 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)

{

MessageBox("写串口失败!");

}

 

}

 

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)

{

 MessageBox("读串口失败!");

}

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",// 串口名称

    GENERIC_READ|GENERIC_WRITE,//允许读和写

    0,//独占方式

    NULL,

    OPEN_EXISTING,//打开而不是创建

    FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//重叠方式

    NULL);

if(hCom==(HANDLE)-1)

{

MessageBox("打开 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();

}