久久久久在线观看,亚洲福利小视频,欧美大片在线看免费观看

Win32串口�~�程

jay — Sun, 15 Jul 2007 07:23:00 GMT

在工业控制中�Q�工控机�Q�一般都��Z��Windows�q�_��Q�经帔R��要与��仪表通过串口�q�行通信。串口通信方便易行�Q�应用广泛�?br> 一般情况下�Q�工控机和各��仪表通过RS485�ȝ��q�行通信。RS485的通信方式是半双工的，只能�׃��Z��节点的工控PC��Z��ơ轮询网�l�上的各��控制单元子节炏V��每�ơ通信都是由PC机通过串口向智能控制单元发布命令，��控制单元在接收到正确的命令后作出应答�?br>　　在Win32下，可以使用两种�~�程方式实现串口通信�Q�其一是��用ActiveX控�g�Q�这�U�方法程序简单，但欠灉|��。其二是调用Windows的API函数�Q�这�U�方法可以清楚地掌握串口通信的机�Ӟ��q�且自由灉|��。本文我们只介绍API串口通信部分�?br>　　串口的操作可以有两种操作方式�Q�同步操作方式和重叠操作方式�Q�又�U�Cؓ异步操作方式�Q�。同步操作时�Q�API函数会阻塞直到操作完成以后才能返回（在多�U�程方式中，虽然不会��d��ȝ��E�，但是仍然会阻塞监听线�E�）�Q�而重叠操作方式，API函数会立卌��回，操作在后台进行，避免�U�程的阻塞�?

无论那种操作方式�Q�一般都通过四个步骤来完成：

�Q?�Q?打开串口

　　Win32�pȝ��把文件的概念�q�行了扩展。无论是文�g、通信讑֤�、命名管道、邮件槽、磁盘、还是控制台�Q�都是用API函数CreateFile来打开或创建的。该函数的原型�ؓ�Q?

HANDLE CreateFile( LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDistribution,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile);

lpFileName�Q�将要打开的串口逻辑名，�?#8220;COM1”�Q?
dwDesiredAccess�Q�指定串口访问的�c�d��Q�可以是��d��、写入或二者�ƈ列；
dwShareMode�Q�指定共享属性，�׃��串口不能�׃�n�Q�该参数必须�|��ؓ0�Q?
lpSecurityAttributes�Q�引用安全性属性结构，�~�省��gؓNULL�Q?
dwCreationDistribution�Q�创建标志，对串口操作该参数必须�|��ؓOPEN_EXISTING�Q?
dwFlagsAndAttributes�Q�属性描�q�ͼ�用于指定该串口是否进行异步操作，该��gؓFILE_FLAG_OVERLAPPED�Q�表�C�Z��用异步的I/O�Q�该��gؓ0�Q�表�C�同步I/O操作�Q?
hTemplateFile�Q�对串口而言该参数必��ȝ��为NULL�Q?

同步I/O方式打开串口的示例代码：

	HANDLE hCom;  //全局变量�Q�串口句�?
hCom=CreateFile("COM1",//COM1�?
GENERIC_READ|GENERIC_WRITE, //允许��d���?
0, //独占方式
NULL,
OPEN_EXISTING, //打开而不是创�?
0, //同步方式
NULL);
if(hCom==(HANDLE)-1)
{
AfxMessageBox("打开COM��p�|!");
return FALSE;
}
return TRUE;

重叠I/O打开串口的示例代码：

	HANDLE hCom;  //全局变量�Q�串口句�?
hCom =CreateFile("COM1",  //COM1�?
GENERIC_READ|GENERIC_WRITE, //允许��d���?
0,  //独占方式
NULL,
OPEN_EXISTING,  //打开而不是创�?
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式
NULL);
if(hCom ==INVALID_HANDLE_VALUE)
{
AfxMessageBox("打开COM��p�|!");
return FALSE;
}
return TRUE;

�Q?�Q��?a name=配置串口>配置串口

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

typedef struct _DCB{
………
//波特率，指定通信讑֤�的传输速率。这个成员可以是实际波特率值或者下面的帔R����g��一�Q?
DWORD BaudRate;
CBR_110�Q�CBR_300�Q�CBR_600�Q�CBR_1200�Q�CBR_2400�Q�CBR_4800�Q�CBR_9600�Q�CBR_19200�Q?CBR_38400�Q?
CBR_56000�Q?CBR_57600�Q?CBR_115200�Q?CBR_128000�Q?CBR_256000�Q?CBR_14400
DWORD fParity; // 指定奇偶校验使能。若此成员�ؓ1�Q�允许奇偶校验检�?
…
BYTE ByteSize; // 通信字节位数�Q?�?
BYTE Parity; //指定奇偶校验�Ҏ(gu��)��。此成员可以有下列��|��
EVENPARITY 偶校�?    NOPARITY 无校�?
MARKPARITY 标记校验   ODDPARITY 奇校�?
BYTE StopBits; //指定停止位的位数。此成员可以有下列��|��
ONESTOPBIT 1位停止位   TWOSTOPBITS 2位停止位
ONE5STOPBITS   1.5位停止位
………
} DCB;
winbase.h文�g中定义了以上用到的常量。如下：
#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 //指向一个设备控制块�Q�DCB�l�构�Q�的指针
);
SetCommState函数讄���COM口的讑֤�控制块：
BOOL SetCommState(
HANDLE hFile,
LPDCB lpDCB
);

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

BOOL SetupComm(
HANDLE hFile,	// 通信讑֤�的句�?
DWORD dwInQueue,	// 输入�~�冲区的大小�Q�字节数�Q?
DWORD dwOutQueue	// 输出�~�冲区的大小�Q�字节数�Q?
);

　　在用ReadFile和WriteFile��d��串行口时�Q�需要考虑��时问题。超时的作用是在指定的时间内没有��d��或发送指定数量的字符�Q�ReadFile或WriteFile的操作仍然会�l�束�?br>　　要查询当前的��时讄��应调用GetCommTimeouts函数�Q�该函数会填充一个COMMTIMEOUTS�l�构。调用SetCommTimeouts可以用某一个COMMTIMEOUTS�l�构的内�Ҏ(gu��)��讄��时�?br>　　��d��串口的超时有两种�Q�间隔超时和总超时。间隔超时是指在接收时两个字�W�之间的最大时延。总超时是指读写操作��d��p��的最大时间。写操作只支持总超�Ӟ��而读操作两种��时均支持。用COMMTIMEOUTS�l�构可以规定��d��操作的超时�?br>COMMTIMEOUTS�l�构的定义�ؓ�Q?

typedef struct _COMMTIMEOUTS {
DWORD ReadIntervalTimeout; //读间隔超�?
DWORD ReadTotalTimeoutMultiplier; //��L��间系�?
DWORD ReadTotalTimeoutConstant; //��L��间常�?
DWORD WriteTotalTimeoutMultiplier; // 写时间系�?
DWORD WriteTotalTimeoutConstant; //写时间常�?
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

COMMTIMEOUTS�l�构的成员都以毫�U��ؓ单位。总超时的计算公式是：
总超�Ӟ��旉��p�L��×要求�?写的字符敎ͼ�旉��帔R��
例如�Q�要��d��10个字�W�，那么��L��作的总超时的计算公式为：
��L��超�Ӟ��ReadTotalTimeoutMultiplier×10�Q�ReadTotalTimeoutConstant
可以看出�Q�间隔超时和总超时的讄��是不相关的，�q�可以方侉K��信�E�序灉|��地设�|�各�U�超时�?

如果所有写��时参数均�ؓ0�Q�那么就不��用写��时。如果ReadIntervalTimeout�?�Q�那么就不��用读间隔��时。如果ReadTotalTimeoutMultiplier �?ReadTotalTimeoutConstant 都�ؓ0�Q�则不��用读总超时。如果读间隔��时被设�|�成MAXDWORD�q�且��L��间系数和��L��间常量都�?�Q�那么在��M��ơ输入缓冲区的内容后��L��作就立即�q�回�Q�而不��是否读入了要求的字�W��?br>　　在用重叠方式��d��串口�Ӟ��虽然ReadFile和WriteFile在完成操作以前就可能�q�回�Q�但��时仍然是�v作用的。在�q�种情况下，��时规定的是操作的完成时��_��而不是ReadFile和WriteFile的返回时间�?br>配置串口的示例代码：

	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; //每个字节�?�?
dcb.Parity=NOPARITY; //无奇偶校验位
dcb.StopBits=TWOSTOPBITS; //两个停止�?
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);

在读写串口之前，�q�要用PurgeComm()函数清空�~�冲区，该函数原型：

BOOL PurgeComm(
HANDLE hFile,	//串口句柄
DWORD dwFlags	// 需要完成的操作
);

参数dwFlags指定要完成的操作�Q�可以是下列值的�l�合�Q?

PURGE_TXABORT	  中断所有写操作�q�立卌���回，即��写操作还没有完成�?
PURGE_RXABORT	  中断所有读操作�q�立卌���回，即����L��作还没有完成�?
PURGE_TXCLEAR	  清除输出�~�冲�?
PURGE_RXCLEAR	  清除输入�~�冲�?

�Q?�Q��?a name=��d��串口>��d��串口

我们使用ReadFile和WriteFile��d��串口�Q�下面是两个函数的声明：

BOOL ReadFile(
HANDLE hFile,	//串口的句�?
// ��d��的数据存储的地址�Q?
// 卌���入的数据���存储在以该指针的��gؓ首地址的一片内存区
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,	// 要读入的数据的字节数
// 指向一个DWORD数��|��该数��D��回读操作实际��d��的字节数
LPDWORD lpNumberOfBytesRead,
// 重叠操作�Ӟ��该参数指向一个OVERLAPPED�l�构�Q�同步操作时�Q�该参数为NULL�?
LPOVERLAPPED lpOverlapped
);
BOOL WriteFile(
HANDLE hFile,	//串口的句�?
// 写入的数据存储的地址�Q?
// 即以该指针的��gؓ首地址的nNumberOfBytesToWrite
// 个字节的数据���要写入串口的发送数据缓冲区�?
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite,	//要写入的数据的字节数
// 指向指向一个DWORD数��|��该数��D��回实际写入的字节�?
LPDWORD lpNumberOfBytesWritten,
// 重叠操作�Ӟ��该参数指向一个OVERLAPPED�l�构�Q?
// 同步操作�Ӟ��该参��CؓNULL�?
LPOVERLAPPED lpOverlapped
);

　　在用ReadFile和WriteFile��d��串口�Ӟ��既可以同步执行，也可以重叠执行。在同步执行�Ӟ��函数直到操作完成后才�q�回。这意味着同步执行时线�E�会被阻塞，从而导致效率下降。在重叠执行�Ӟ��即��操作�q�未完成�Q�这两个函数也会立即�q�回�Q�费时的I/O操作在后台进行�?br>　　ReadFile和WriteFile函数是同步还是异步由CreateFile函数军_��Q�如果在调用CreateFile创徏句柄时指定了FILE_FLAG_OVERLAPPED标志�Q�那么调用ReadFile和WriteFile对该句柄�q�行的操作就应该是重叠的�Q�如果未指定重叠标志�Q�则��d��操作应该是同步的。ReadFile和WriteFile函数的同步或者异步应该和CreateFile函数�怸�致�?br>　　ReadFile函数只要在串口输入缓冲区中读入指定数量的字符�Q�就��完成操作。而WriteFile函数不但要把指定数量的字�W�拷入到输出�~�冲区，而且要等�q�些字符从串行口送出��d��才算完成操作�?br>　　如果操作成功�Q�这两个函数都返回TRUE。需要注意的是，当ReadFile和WriteFile�q�回FALSE�Ӟ��不一定就是操作失败，�U�程应该调用GetLastError函数分析�q�回的结果。例如，在重叠操作时如果操作�q�未完成函数��p��回，那么函数��p��回FALSE�Q�而且GetLastError函数�q�回ERROR_IO_PENDING。这说明重叠操作�q�未完成�?br>
同步方式��d��串口比较��单，下面先例丑֐�步方式读写串口的代码�Q?

//同步��M���?
char str[100];
DWORD wCount;//��d��的字节数
BOOL bReadStat;
bReadStat=ReadFile(hCom,str,100,&wCount,NULL);
if(!bReadStat)
{
AfxMessageBox("��M��口失�?");
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);

在重叠操作时,操作�q�未完成函数��p��回�?

　　重叠I/O非常灉|��Q�它也可以实现阻塞（例如我们可以讄��一定要��d��C��个数据才能进行到下一步操作）。有两种�Ҏ(gu��)��可以�{�待操作完成�Q�一�U�方法是用象WaitForSingleObject�q�样的等待函数来�{�待OVERLAPPED�l�构的hEvent成员�Q�另一�U�方法是调用GetOverlappedResult函数�{�待�Q�后面将演示说明�?br>下面我们先简单说一下OVERLAPPED�l�构和GetOverlappedResult函数�Q?br>OVERLAPPED�l�构
OVERLAPPED�l�构包含了重叠I/O的一些信息，定义如下�Q?

typedef struct _OVERLAPPED { // o
DWORD  Internal;
DWORD  InternalHigh;
DWORD  Offset;
DWORD  OffsetHigh;
HANDLE hEvent;
} OVERLAPPED;

　　在��用ReadFile和WriteFile重叠操作�Ӟ��U�程需要创建OVERLAPPED�l�构以供�q�两个函��C��用。线�E�通过OVERLAPPED�l�构获得当前的操作状态，该结构最重要的成员是hEvent。hEvent是读写事件。当串口使用异步通讯�Ӟ��函数�q�回时操作可能还没有完成�Q�程序可以通过��查该事�g得知是否��d��完毕�?br>　　当调用ReadFile, WriteFile 函数的时候，该成员会自动被置为无信号状态；当重叠操作完成后�Q�该成员变量会自动被�|��ؓ有信��L��态�?

GetOverlappedResult函数
BOOL GetOverlappedResult(
HANDLE hFile,	// 串口的句�?
// 指向重叠操作开始时指定的OVERLAPPED�l�构
LPOVERLAPPED lpOverlapped,
// 指向一�?2位变量，该变量的��D��回实际读写操作传输的字节数�?
LPDWORD lpNumberOfBytesTransferred,
// 该参数用于指定函数是否一直等到重叠操作结束�?
// 如果该参��CؓTRUE�Q�函数直到操作结束才�q�回�?
// 如果该参��CؓFALSE�Q�函数直接返回，�q�时如果操作没有完成�Q?
// 通过调用GetLastError()函数会返回ERROR_IO_INCOMPLETE�?
BOOL bWait
);

该函数返回重叠操作的�l�果�Q�用来判断异步操作是否完成，它是通过判断OVERLAPPED�l�构中的hEvent是否被置位来实现的�?br>
异步��M��口的�C�Z��代码�Q?

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函数�q�回FALSE
{
if(GetLastError()==ERROR_IO_PENDING)
//GetLastError()函数�q�回ERROR_IO_PENDING,表明串口正在�q�行��L���?
{
WaitForSingleObject(m_osRead.hEvent,2000);
//使用WaitForSingleObject函数�{�待�Q�直到读操作完成或�g时已辑ֈ�2�U�钟
//当串口读操作�q�行完毕后，m_osRead的hEvent事�g会变为有信号
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 函数�q�行��L��作前�Q�应先��用ClearCommError函数清除错误。ClearCommError函数的原型如下：

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

该函数获得通信错误�q�报告串口的当前状态，同时�Q�该函数清除串口的错误标志以便��l�输入、输出操作�?br>参数l(f��)pStat指向一个COMSTAT�l�构�Q�该�l�构�q�回串口状态信息�?COMSTAT�l�构 COMSTAT�l�构包含串口的信息，�l�构定义如下�Q?

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;

本文只用��C��cbInQue成员变量�Q�该成员变量的��g��表输入缓冲区的字节数�?br>
　　最后用PurgeComm函数清空串口的输入输出缓冲区�?

　　�q�段代码用WaitForSingleObject函数来等待OVERLAPPED�l�构的hEvent成员�Q�下面我们再演示一�D�调用GetOverlappedResult函数�{�待的异步读串口�C�Z��代码�Q?

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函数�q�回FALSE
{
if(GetLastError()==ERROR_IO_PENDING)
{
GetOverlappedResult(hCom,
&m_osRead,&dwBytesRead,TRUE);
// GetOverlappedResult函数的最后一个参数设为TRUE�Q?
//函数会一直等待，直到��L��作完成或�׃��错误而返回�?
return dwBytesRead;
}
return 0;
}
return dwBytesRead;

异步写串口的�C�Z��代码�Q?

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;

�Q?�Q��?a name=关闭串口>关闭串口

　　利用API函数关闭串口非常��单，只需使用CreateFile函数�q�回的句柄作为参数调用CloseHandle卛_��Q?

BOOL CloseHandle(
HANDLE hObject; //handle to object to close
);

串口�~�程的一个实�?

　　��Z��让�?zh��n)�更好地理解串口编�E?下面我们分别�~�写两个例程�Q�见附带的源码部分）,�q�两个例�E�都实现了工控机与百�Ҏ(gu��)��C�Z�A表通过RS485接口�q�行的串口通信。其中第一个例�E�采用同步串口操�?�W�二个例�E�采用异步串口操作�?br>　　我们只介�l��Y仉��分，RS485接口接线�Ҏ(gu��)��不作介绍�Q�感兴趣的读者可以查阅相兌��料�?/p>

例程1

　　打开VC++6.0�Q�新建基于对话框的工�E�RS485Comm�Q�在��d��话框�H�口IDD_RS485COMM_DIALOG上添加两个按钮，ID分别为IDC_SEND和IDC_RECEIVE�Q�标题分别�ؓ“发�?#8221;�?#8220;接收”�Q�添加一个静态文本框IDC_DISP�Q�用于显�C�Z��口接收到的内宏V�?br>
在RS485CommDlg.cpp文�g中添加全局变量�Q?

HANDLE hCom;  //全局变量�Q�串口句�?

在RS485CommDlg.cpp文�g中的OnInitDialog()函数��d��如下代码�Q?

	// TODO: Add extra initialization here
hCom=CreateFile("COM1",//COM1�?
GENERIC_READ|GENERIC_WRITE, //允许��d���?
0, //独占方式
NULL,
OPEN_EXISTING, //打开而不是创�?
0, //同步方式
NULL);
if(hCom==(HANDLE)-1)
{
AfxMessageBox("打开COM��p�|!");
return FALSE;
}
SetupComm(hCom,100,100); //输入�~�冲区和输出�~�冲区的大小都是1024
COMMTIMEOUTS TimeOuts;
//讑֮�读超�?
TimeOuts.ReadIntervalTimeout=MAXDWORD;
TimeOuts.ReadTotalTimeoutMultiplier=0;
TimeOuts.ReadTotalTimeoutConstant=0;
//在读一�ơ输入缓冲区的内容后��L��作就立即�q�回�Q?
//而不���是否读入了要求的字�W��?
//讑֮�写超�?
TimeOuts.WriteTotalTimeoutMultiplier=100;
TimeOuts.WriteTotalTimeoutConstant=500;
SetCommTimeouts(hCom,&TimeOuts); //讄������时
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率�ؓ9600
dcb.ByteSize=8; //每个字节�?�?
dcb.Parity=NOPARITY; //无奇偶校验位
dcb.StopBits=TWOSTOPBITS; //两个停止�?
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);

分别双击IDC_SEND按钮和IDC_RECEIVE按钮�Q�添加两个按钮的响应函数�Q?

void CRS485CommDlg::OnSend()
{
// TODO: Add your control notification handler code here
// 在此需要简单介�l�百特公司XMA5000的通讯协议�Q?
//该��A表RS485通讯采用��L���q�播方式通讯�?
//串行半双工，�?1位，1个�v始位(0)�Q?个数据位�Q?个停止位(1)
//如：��M�A表显�C�的瞬时��|����L��发送：DC1 AAA BB ETX
//其中�Q�DC1是标准ASCII码的一个控制符��P��码��gؓ11H(十进制的17)
//在XMA5000的通讯协议中，DC1表示�ȝ��时�?
//AAA是从机地址码，也就是XMA5000昄���仪表的通讯地址
//BB为通道��P���ȝ��时值时该��gؓ01
//ETX也是标准ASCII码的一个控制符��P��码��gؓ03H
//在XMA5000的通讯协议中，ETX表示��L���l�束�W?
char lpOutBuffer[7];
memset(lpOutBuffer,''\0'',7); //�?个字节先清零
lpOutBuffer[0]=''\x11'';  //发送缓冲区的第1个字节�ؓDC1
lpOutBuffer[1]=''0'';  //�W?个字节�ؓ字符0(30H)
lpOutBuffer[2]=''0''; //�W?个字节�ؓ字符0(30H)
lpOutBuffer[3]=''1''; // �W?个字节�ؓ字符1(31H)
lpOutBuffer[4]=''0''; //�W?个字节�ؓ字符0(30H)
lpOutBuffer[5]=''1''; //�W?个字节�ؓ字符1(31H)
lpOutBuffer[6]=''\x03''; //�W?个字节�ؓ字符ETX
//从该�D�代码可以看出，仪表的通讯地址�?01
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;//��d��的字节数
BOOL bReadStat;
bReadStat=ReadFile(hCom,str,wCount,&wCount,NULL);
if(!bReadStat)
AfxMessageBox("��M��口失�?");
PurgeComm(hCom, PURGE_TXABORT|
PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
m_disp=str;
UpdateData(FALSE);
}

�(zh��n)�可以观察返回的字符�Ԍ��其中有和仪表昄��值相同的部分�Q��?zh��n)�可以�q�行相应的字�W�串操作取出仪表的显�C�倹{�?br>打开ClassWizard,为静态文本框IDC_DISP��d��CString�c�d��变量m_disp�Q�同时添加WM_CLOSE的相应函敎ͼ�

void CRS485CommDlg::OnClose()
{
// TODO: Add your message handler code here and/or call default
CloseHandle(hCom);	//�E�序退出时关闭串口
CDialog::OnClose();
}

�E�序的相应部分已�l�在代码内部作了详细介绍。连接好��g部分�Q�编译运行程序，�l�心体会串口同步操作部分�?

例程2

　　打开VC++6.0�Q�新建基于对话框的工�E�RS485Comm�Q�在��d��话框�H�口IDD_RS485COMM_DIALOG上添加两个按钮，ID分别为IDC_SEND和IDC_RECEIVE�Q�标题分别�ؓ“发�?#8221;�?#8220;接收”�Q�添加一个静态文本框IDC_DISP�Q�用于显�C�Z��口接收到的内宏V��在RS485CommDlg.cpp文�g中添加全局变量�Q?

HANDLE hCom; //全局变量�Q?/pre>
串口句柄在RS485CommDlg.cpp文�g中的OnInitDialog()函数��d��如下代码�Q?
	hCom=CreateFile("COM1",//COM1�?
GENERIC_READ|GENERIC_WRITE, //允许��d���?
0, //独占方式
NULL,
OPEN_EXISTING, //打开而不是创�?
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重叠方式
NULL);
if(hCom==(HANDLE)-1)
{
AfxMessageBox("打开COM��p�|!");
return FALSE;
}
SetupComm(hCom,100,100); //输入�~�冲区和输出�~�冲区的大小都是100
COMMTIMEOUTS TimeOuts;
//讑֮�读超�?
TimeOuts.ReadIntervalTimeout=MAXDWORD;
TimeOuts.ReadTotalTimeoutMultiplier=0;
TimeOuts.ReadTotalTimeoutConstant=0;
//在读一�ơ输入缓冲区的内容后��L��作就立即�q�回�Q?
//而不���是否读入了要求的字�W��?
//讑֮�写超�?
TimeOuts.WriteTotalTimeoutMultiplier=100;
TimeOuts.WriteTotalTimeoutConstant=500;
SetCommTimeouts(hCom,&TimeOuts); //讄������时
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率�ؓ9600
dcb.ByteSize=8; //每个字节�?�?
dcb.Parity=NOPARITY; //无奇偶校验位
dcb.StopBits=TWOSTOPBITS; //两个停止�?
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);

分别双击IDC_SEND按钮和IDC_RECEIVE按钮�Q�添加两个按钮的响应函数�Q?
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;//��d��的字节数
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()函数�q�回ERROR_IO_PENDING,表明串口正在�q�行��L���?
{
WaitForSingleObject(m_osRead.hEvent,2000);
//使用WaitForSingleObject函数�{�待�Q�直到读操作完成或�g时已辑ֈ�2�U�钟
//当串口读操作�q�行完毕后，m_osRead的hEvent事�g会变为有信号
}
}
PurgeComm(hCom, PURGE_TXABORT|
PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
m_disp=str;
UpdateData(FALSE);
}

打开ClassWizard,为静态文本框IDC_DISP��d��CString�c�d��变量m_disp�Q�同时添加WM_CLOSE的相应函敎ͼ�
void CRS485CommDlg::OnClose()
{
// TODO: Add your message handler code here and/or call default
CloseHandle(hCom);	//�E�序退出时关闭串口
CDialog::OnClose();
}



jay 2007-07-15 15:23 发表评论

深入��出VC++串口�~�程之基于Win32 API

jay — Wed, 11 Jul 2007 14:27:00 GMT

1、API描述

　　在WIN32 API中，串口使用文�g方式�q�行讉K��Q�其操作的API基本上与文�g操作的API一致�?br>
　　打开串口

　　Win32 中用于打开串口的API 函数为CreateFile�Q�其原型为：

HANDLE CreateFile (
　LPCTSTR lpFileName, //��要打开的串口逻辑名，如COM1 或COM2
　DWORD dwAccess, //指定串口讉K��的类型，可以是读取、写入或两者�ƈ�?br>　DWORD dwShareMode, //指定�׃�n属性，�׃��串口不能�׃�n,该参数必��ȝ��?
　LPSECURITY_ATTRIBUTES lpsa, //引用安全性属性结构，�~�省��gؓNULL
　DWORD dwCreate, //创徏标志�Q�对串口操作该参数必��ȝ��为OPEN EXISTING
　DWORD dwAttrsAndFlags, //属性描�q�ͼ�用于指定该串口是否可�q�行异步操作�Q?br>　//FILE_FLAG_OVERLAPPED�Q�可使用异步的I/O
　HANDLE hTemplateFile //指向模板文�g的句柄，对串口而言该参数必��ȝ��为NULL
);

　　例如�Q�以下程序用于以同步��d��方式打开串口COM1�Q?br>

HANDLE hCom;
DWORD dwError;
hCon = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if (hCom == (HANDLE)0xFFFFFFFF)
{
　dwError = GetLastError();
　MessageBox(dwError);
}

　　对于dwAttrsAndFlags参数及FILE_FLAG_OVERLAPPED标志的由来，可解释如下：Windows文�g操作分�ؓ同步I/O和重叠I/O(Overlapped I/ O)两种方式�Q�在同步I/O方式中，API会阻塞直到操作完成以后才能返回（在多�U�程方式中，虽然不会��d��ȝ��E�，但是仍然会阻塞监听线�E�）�Q�而在重叠I/O方式中，API会立卌��回，操作在后台进行，避免�U�程的阻塞。重叠I/O非常灉|��Q�它也可以实现阻塞（例如我们可以讄��一定要��d��C��个数据才能进行到下一步操�?。如果进行I/O操作的API 在没有完成操作的情况下返回，我们可以通过调用GetOverLappedResult()函数��d��到I/O操作完成后返回�?br>
　　配置串口

　　配置串口是通过改变讑֤�控制块DCB(Device Control Block) 的成员变量值来实现的，接收�~�冲区和发送缓冲区的大��可通过SetupComm函数来设�|��?br>
　　DCB�l�构体定义�ؓ�Q?br>

typedef struct _DCB { // dcb
　DWORD DCBlength; // sizeof(DCB)
　DWORD BaudRate; // current baud rate
　DWORD fBinary: 1; // binary mode, no EOF check
　DWORD fParity: 1; // enable parity checking
　DWORD fOutxCtsFlow:1; // CTS output flow control
　DWORD fOutxDsrFlow:1; // DSR output flow control
　DWORD fDtrControl:2; // DTR flow control type
　DWORD fDsrSensitivity:1; // DSR sensitivity
　DWORD fTXContinueOnXoff:1; // XOFF continues Tx
　DWORD fOutX: 1; // XON/XOFF out flow control
　DWORD fInX: 1; // XON/XOFF in flow control
　DWORD fErrorChar: 1; // enable error replacement
　DWORD fNull: 1; // enable null stripping
　DWORD fRtsControl:2; // RTS flow control
　DWORD fAbortOnError:1; // abort reads/writes on error
　DWORD fDummy2:17; // reserved
　WORD wReserved; // not currently used
　WORD XonLim; // transmit XON threshold
　WORD XoffLim; // transmit XOFF threshold
　BYTE ByteSize; // number of bits/byte, 4-8
　BYTE Parity; // 0-4=no,odd,even,mark,space
　BYTE StopBits; // 0,1,2 = 1, 1.5, 2
　char XonChar; // Tx and Rx XON character
　char XoffChar; // Tx and Rx XOFF character
　char ErrorChar; // error replacement character
　char EofChar; // end of input character
　char EvtChar; // received event character
　WORD wReserved1; // reserved; do not use
} DCB;
而SetupComm函数的原型则为：
BOOL SetupComm(
　HANDLE hFile, // handle to communications device
　DWORD dwInQueue, // size of input buffer
　DWORD dwOutQueue // size of output buffer
);

　　以下�E�序��串口设�|��ؓ�Q��L特率�?600�Q�数据位��Cؓ7位，停止位�ؓ2 位，偶校验，接收�~�冲区和发送缓冲区大小均�ؓ1024个字节，最后用PurgeComm函数�l�止所有的后台��d��操作�q�清�I�接收缓冲区和发送缓冲区�Q?/p>

DCB dcb;
dcb.BaudRate = 9600; //波特率�ؓ9600
dcb.ByteSize = 7; //数据位数�?�?br>dcb.Parity = EVENPARITY; //偶校�?br>dcb.StopBits = 2; //两个停止�?br>dcb.fBinary = TRUE;
dcb.fParity = TRUE;
if (!SetCommState(hCom, &dcb))
{
　MessageBox("串口讄��出错!");
}
SetupComm(hCom, 1024, 1024);
PurgeComm(hCom, PURCE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);

　　��时讄��

　　��时讄��是通过改变COMMTIMEOUTS�l�构体的成员变量值来实现的，COMMTIMEOUTS的原型�ؓ�Q?br>

typedef struct _COMMTIMEOUTS
{
　DWORD ReadIntervalTimeout; //定义两个字符到达的最大时间间隔，单位�Q�毫�U?br>　//当读取完一个字�W�后�Q�超�q�了ReadIntervalTimeout�Q�仍未读取到下一个字�W�，��׃��
　//发生��时
　DWORD ReadTotalTimeoutMultiplier;
　DWORD ReadTotalTimeoutConstant;
　//其中各时间所满��的关�p�d��下：
　//ReadTotalTimeout = ReadTotalTimeOutMultiplier* BytesToRead + ReadTotalTimeoutConstant
　DWORD WriteTotalTimeoutMultiplier;
　DWORD WriteTotalTimeoutConstant;
} COMMTIMEOUTS, *LPCOMMTIMEOUTS;

　　讄��时的函��CؓSetCommTimeouts�Q�其原型中接收COMMTIMEOUTS的指针�ؓ参数�Q?br>

BOOL SetCommTimeouts(
　HANDLE hFile, // handle to communications device
　LPCOMMTIMEOUTS lpCommTimeouts // pointer to comm time-out structure
);

　　以下�E�序��串口读操作的超时设定�ؓ10 毫秒�Q?br>

COMMTIMEOUTS to;
memset(&to, 0, sizeof(to));
to.ReadIntervalTimeout = 10;
SetCommTimeouts(hCom, &to);

　　与SetCommTimeouts对应的GetCommTimeouts()函数的原型�ؓ�Q?br>

BOOL GetCommTimeouts(
　HANDLE hFile, // handle of communications device
　LPCOMMTIMEOUTS lpCommTimeouts // pointer to comm time-out structure
);

　　事�g讄��

　　在读写串口之前，需要用SetCommMask ()函数讄��事�g掩模来监视指定通信端口上的事�g�Q�其原型为：

BOOL SetCommMask(
　HANDLE hFile, //标识通信端口的句�?br>　DWORD dwEvtMask //能够使能的通信事�g
);

　　有了Set当然�q�会有Get�Q�与SetCommMask对应的GetCommMask()函数的原型�ؓ�Q?br>

BOOL GetCommMask(
　HANDLE hFile, //标识通信端口的句�?br>　LPDWORD lpEvtMask // address of variable to get event mask
);

　　串口上可以发生的事�g可以是如下事件列表中的一个或��L��l�合�Q�EV_BREAK、EV_CTS、EV_DSR、EV_ERR、EV_RING、EV_RLSD、EV_RXCHAR、EV_RXFLAG、EV_TXEMPTY�?br>
　　我们可以用WaitCommEvent()函数来等待串口上我们利用SetCommMask ()函数讄��的事�Ӟ��

BOOL WaitCommEvent(
　HANDLE hFile, //标识通信端口的句�?br>　LPDWORD lpEvtMask, // address of variable for event that occurred
　LPOVERLAPPED lpOverlapped, // address of overlapped structure
);

　　WaitCommEvent()函数一直阻塞，直到串口上发生我们用所SetCommMask ()函数讄��的通信事�g为止。一般而言�Q�当WaitCommEvent()�q�回�Ӟ��E�序员可以由分析*lpEvtMask而获得发生事件的�c�d��Q�再�q�行相应的处理�?br>
　　��M��?br>
　　对串口进行读取所用的函数和对文�g�q�行��d��所用的函数相同�Q�读函数原型如下�Q?br>

BOOL ReadFile(
　HANDLE hFile, // handle of file to read
　LPVOID lpBuffer, // pointer to buffer that receives data
　DWORD nNumberOfBytesToRead, // number of bytes to read
　LPDWORD lpNumberOfBytesRead, // pointer to number of bytes read
　LPOVERLAPPED lpOverlapped // pointer to structure for overlapped I/O
);

　　写串�?br>
　　对串口进行写入所用的函数和对文�g�q�行写入所用的函数相同�Q�写函数原型如下�Q?br>

BOOL WriteFile(
　HANDLE hFile, // handle to file to write to
　LPCVOID lpBuffer, // pointer to data to write to file
　DWORD nNumberOfBytesToWrite, // number of bytes to write
　LPDWORD lpNumberOfBytesWritten, // pointer to number of bytes written
　LPOVERLAPPED lpOverlapped // pointer to structure for overlapped I/O
);

　　关闭串口

　　利用API 函数实现串口通信时关闭串口非常简单，只需使用CreateFile 函数�q�回的句柄作为参数调用CloseHandle 卛_��Q?br>

BOOL CloseHandle(
　HANDLE hObject // handle to object to close
);

2.例程

　　在笔者的《深入浅出Win32多线�E�程序设计之�l�合实例》中我们已经�l�出一个利用WIN API�q�行串口通信的例子，�q�里再给��Z��个类似的例子�Q�以�q�一步加��q��解�?br>

利用WIN API�q�行串口通信

　　对话框上控�g对应的资源文�?.RC)中的内容如下�Q?br>

BEGIN
　EDITTEXT IDC_RECV_EDIT,28,119,256,46,ES_AUTOHSCROLL
　GROUPBOX "发送数�?,IDC_STATIC,19,15,282,70
　GROUPBOX "接收数据",IDC_STATIC,19,100,282,80
　EDITTEXT IDC_SEND_EDIT,29,33,214,39,ES_AUTOHSCROLL
　PUSHBUTTON "清除",IDC_CLEAR_BUTTON,248,33,50,14
　PUSHBUTTON "发�?,IDC_SEND_BUTTON,248,55,50,14
END

　　而整个对话框的消息映��（描述了消息及其对应的行�ؓ�Q�如下：

BEGIN_MESSAGE_MAP(CSerialPortAPIDlg, CDialog)
//{{AFX_MSG_MAP(CSerialPortAPIDlg)
　ON_WM_SYSCOMMAND()
　ON_WM_PAINT()
　ON_WM_QUERYDRAGICON()
　ON_BN_CLICKED(IDC_CLEAR_BUTTON, OnClearButton)
　ON_BN_CLICKED(IDC_SEND_BUTTON, OnSendButton)
　ON_MESSAGE(COM_RECVDATA, OnRecvData)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

　　我们为IDC_SEND_EDIT和IDC_RECV_EDIT�~�辑框控件分别添加了一个CString变量m_recv和m_send�Q�下面的代码描述了这一行�ؓ�Q?br>

class CSerialPortAPIDlg : public CDialog
{
　// Construction
　public:
　　CSerialPortAPIDlg(CWnd* pParent = NULL); // standard constructor

　　// Dialog Data
　　//{{AFX_DATA(CSerialPortAPIDlg)
　　　enum { IDD = IDD_SERIALPORTAPI_DIALOG };
　　　CString m_recv; //IDC_RECV_EDIT控�g对应的变�?br>　　　CString m_send; //IDC_SEND_EDIT控�g对应的变�?br>　　//}}AFX_DATA

　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CSerialPortAPIDlg)
　protected:
　　virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
　//}}AFX_VIRTUAL

　// Implementation
　protected:
　　BOOL OpenSerialPort1();
　　HICON m_hIcon;

　　// Generated message map functions
　　//{{AFX_MSG(CSerialPortAPIDlg)
　　　virtual BOOL OnInitDialog();
　　　afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
　　　afx_msg void OnPaint();
　　　afx_msg HCURSOR OnQueryDragIcon();
　　　afx_msg void OnClearButton();
　　　afx_msg void OnSendButton();
　　　afx_msg void OnRecvData(WPARAM wParam, LPARAM lParam);
　　//}}AFX_MSG
　　DECLARE_MESSAGE_MAP()
};

CSerialPortAPIDlg::CSerialPortAPIDlg(CWnd* pParent /*=NULL*/)
: CDialog(CSerialPortAPIDlg::IDD, pParent)
{
　//{{AFX_DATA_INIT(CSerialPortAPIDlg)
　　//在构造函��C��初始化变�?br>　　m_recv = _T(""); //在构造函��C��初始化变�?br>　　m_send = _T("");
　//}}AFX_DATA_INIT
　// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
　m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

//建立�~�辑框控件和变量之间的映��?br>void CSerialPortAPIDlg::DoDataExchange(CDataExchange* pDX)
{
　CDialog::DoDataExchange(pDX);
　//{{AFX_DATA_MAP(CSerialPortAPIDlg)
　　DDX_Text(pDX, IDC_RECV_EDIT, m_recv);
　　DDX_Text(pDX, IDC_SEND_EDIT, m_send);
　//}}AFX_DATA_MAP
}

　　在对话框的OnInitDialog()函数中，我们启动�H�口监听�U�程�q�将�ȝ��口句柄传递给�U�程控制函数�Q?/p>

BOOL CSerialPortAPIDlg::OnInitDialog()
{
　CDialog::OnInitDialog();

　// Add "About..." menu item to system menu.

　// IDM_ABOUTBOX must be in the system command range.
　ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
　ASSERT(IDM_ABOUTBOX < 0xF000);

　CMenu* pSysMenu = GetSystemMenu(FALSE);
　if (pSysMenu != NULL)
　{
　　CString strAboutMenu;
　　strAboutMenu.LoadString(IDS_ABOUTBOX);
　　if (!strAboutMenu.IsEmpty())
　　{
　　　pSysMenu->AppendMenu(MF_SEPARATOR);
　　　pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
　　}
　}

　// Set the icon for this dialog. The framework does this automatically
　// when the application's main window is not a dialog
　SetIcon(m_hIcon, TRUE); // Set big icon
　SetIcon(m_hIcon, FALSE); // Set small icon

　// TODO: Add extra initialization here
　//启动串口监视�U�程
　DWORD threadID;
　hCommThread = ::CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
　　　　　(LPTHREAD_START_ROUTINE)SerialPort1ThreadProcess,
　AfxGetMainWnd()->m_hWnd, 0, &threadID);
　if (hCommThread == NULL)
　{
　　::AfxMessageBox("创徏串口1处理�U�程��p�|");
　　::PostQuitMessage(0);
　}
　return TRUE; // return TRUE unless you set the focus to a control
}

//"清除"按钮函数
void CSerialPortAPIDlg::OnClearButton()
{
　// TODO: Add your control notification handler code here
　m_send = "";
　UpdateData(false);
}

//发送数据函敎ͼ�"发�?按钮函数�Q?br>void CSerialPortAPIDlg::OnSendButton()
{
　// TODO: Add your control notification handler code here
　UpdateData(true);
　DWORD wCount = 0;
　WriteFile(hCom, m_send, m_send.GetLength(), &wCount, NULL);//发送数�?br>}

//接收数据后（通过监听�U�程发来的用戯��定义消息�Q�显�C?br>void CSerialPortAPIDlg::OnRecvData(WPARAM wParam, LPARAM lParam)
{
　CString recvStr((char *)wParam);
　m_recv += recvStr;
　UpdateData(false);
}

　　在工�E�中��d��SerialPortControl.h和SerialPortControl.cpp两个文�g�Q�前者声明串口控制的接口函数及外部全局变量�Q�后者实��C��口接口函数及串口监听�U�程控制函数�?br>
　　SerialPortControl.h文�g

#ifndef _SERIAL_PORT_CONTROL_H
#define _SERIAL_PORT_CONTROL_H

#define COM_RECVDATA WM_USER+1000//自定义消�?br>
extern HANDLE hCom; //全局变量�Q�串口句�?br>extern HANDLE hCommThread; //全局变量�Q�串口线�E?br>//串口监视�U�程控制函数
extern DWORD WINAPI SerialPort1ThreadProcess(HWND hWnd);
//打开�q�设�|�PC串口1(COM1)
extern BOOL OpenSerialPort1();

#endif
SerialPortControl.cpp文�g
#include "StdAfx.h"
#include "SerialPortControl.h"

HANDLE hCom; //全局变量�Q�串口句�?br>HANDLE hCommThread; //全局变量�Q�串口线�E?br>
BOOL OpenSerialPort1()
{
　//打开�q�设�|�COM1
　hCom=CreateFile("COM1", GENERIC_READ|GENERIC_WRITE, 0,NULL , OPEN_EXISTING, 0, NULL);
　if (hCom==(HANDLE)-1)
　{
　　AfxMessageBox("打开COM1��p�|");
　　return false;
　}
　else
　{
　　DCB wdcb;
　　GetCommState (hCom, &wdcb);
　　wdcb.BaudRate=9600;//波特率：9600�Q�其他：不变
　　SetCommState (hCom, &wdcb);
　　PurgeComm(hCom, PURGE_TXCLEAR);
　}
　return true;
}

//以一个线�E�不同监控串口行接收的数�?br>DWORD WINAPI SerialPort1ThreadProcess( HWND hWnd//�ȝ��口句�?
{
　char str[101];
　DWORD wCount; //��d��的字节数
　while(1)
　{
　　ReadFile(hCom,str, 100, &wCount, NULL);
　　if(wCount > 0) //收到数据
　　{
　　　str[wCount] = '\0';
　　　::PostMessage(hWnd, COM_RECVDATA, (unsigned int) str, wCount);
　　　//发送消息给对话框主�H�口�Q�以�q�行接收内容的显�C?br>　　}
　}
　return TRUE;
}

　　��Z��验证�E�序的正��性，我们使用串口调试助手与本�E�序协同工作�Q�互相进行收发。下面的抓图昄��本程序工作正��，发送和接收字符准确无误�?br>

昄��本程序工作正��，发送和接收字符准确无误

jay 2007-07-11 22:27 发表评论

久久久久在线观看,亚洲福利小视频,欧美大片在线看免费观看

Win32串口�~�程

深入���出VC++串口�~�程之基于Win32 API

深入��出VC++串口�~�程之基于Win32 API