那位大哥会串口通信帮帮小弟

[DADONGDONG]

那位大哥会串口通信帮帮小弟，利用MSCOMM控件进行通信，小弟不甚感激，

[向立天]

产口通信倒是会
不过还真没用过MSCOMM
不过你没说你要干嘛呀

[dinjay]

http://www.builder.com.cn/2007/1020/568180.shtml、
希望对你有帮助

[这不是鸭头]

API 的经常写。那个控件的没写过....

[zdqKris]

利用MSCOMM控件进行通信很容易实现啊，在界面上放两个MSCOMM控件，一个初始化为com1，一个为
com2(com1 和 com2在硬件上是连接的，也可以用虚拟串口来实现)，MS已经为他们封装了消息映射，
你在对应函数添加数据处理代码就行

[wencheng2998]

我以前写过串口方面的。。。
在我博客里面有一篇这方面的 MSCOMM
http://blog.csdn.net/wencheng2998/archive/2010/04/04/5449277.aspx

[etz2008]

我刚做过
用API写的类来的感觉挺不错
发给你吧

//   Serial.h   

#ifndef   __SERIAL_H__   
#define   __SERIAL_H__   

#define   FC_DTRDSR               0x01   
#define   FC_RTSCTS               0x02   
#define   FC_XONXOFF             0x04   
#define   ASCII_BEL               0x07   
#define   ASCII_BS                 0x08   
#define   ASCII_LF                 0x0A   
#define   ASCII_CR                 0x0D   
#define   ASCII_XON               0x11   
#define   ASCII_XOFF             0x13   

class   CSerial   
{       
public:   
	CSerial();   
	~CSerial();    
	BOOL Open(int nPort=1,int nBaud= 38400);   
	BOOL Close(void);   
    
	int ReadData( void *,int );   
	int SendData( const char *,int);   
	int ReadDataWaiting(void);   
    
	BOOL IsOpened(void)
	{   
		return m_bOpened;   
	}   
    
protected:   
	BOOL WriteCommByte(unsigned char);   
    
	HANDLE m_hIDComDev;   
	OVERLAPPED m_OverlappedRead,m_OverlappedWrite;   
	BOOL m_bOpened;     
};   

#endif   

//   Serial.cpp   

#include   "stdafx.h"   
#include   "Serial.h"     
CSerial::CSerial()   
{  
	memset(&m_OverlappedRead,0,sizeof(OVERLAPPED));
	memset(&m_OverlappedWrite, 0, sizeof(OVERLAPPED)); 
	m_hIDComDev= NULL; 
	m_bOpened=FALSE;   
}   

CSerial::~CSerial()   
{   
	Close();   
}   

BOOL CSerial::Open(int nPort,int nBaud)   
{
	if(m_bOpened)   
		return TRUE;
	char szPort[15];
	char szComParams[50];
	DCB dcb;
	wsprintf(szPort,"COM%d",nPort); 
	m_hIDComDev=CreateFile(szPort, GENERIC_READ|GENERIC_WRITE,0,NULL,
		OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,NULL);  
	if(m_hIDComDev==NULL)   
		return FALSE;
	
	memset(&m_OverlappedRead,0,sizeof(OVERLAPPED));
	memset(&m_OverlappedWrite,0,sizeof(OVERLAPPED));   
    
	COMMTIMEOUTS CommTimeOuts;   
	CommTimeOuts.ReadIntervalTimeout=0xFFFFFFFF;   
	CommTimeOuts.ReadTotalTimeoutMultiplier=0;   
	CommTimeOuts.ReadTotalTimeoutConstant=0;   
	CommTimeOuts.WriteTotalTimeoutMultiplier=0;   
	CommTimeOuts.WriteTotalTimeoutConstant=5000;   
	SetCommTimeouts(m_hIDComDev,&CommTimeOuts   );   
    
	wsprintf(szComParams,"COM%d:%d,n,8,1",nPort,nBaud);   
    
	m_OverlappedRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);   
	m_OverlappedWrite.hEvent= CreateEvent(NULL,TRUE,FALSE,NULL);   
    
	dcb.DCBlength=sizeof(DCB);   
	GetCommState(m_hIDComDev,&dcb);   
	dcb.BaudRate=nBaud;   
	dcb.ByteSize=8;   
	unsigned   char   ucSet;   
	ucSet=(unsigned   char)((FC_RTSCTS & FC_DTRDSR)!=0);   
	ucSet=(unsigned   char)((FC_RTSCTS & FC_RTSCTS)!=0);   
	ucSet=(unsigned   char)((FC_RTSCTS & FC_XONXOFF)!=0);   
	if(!SetCommState(m_hIDComDev,&dcb) || !SetupComm(m_hIDComDev,10000,10000) 
		|| m_OverlappedRead.hEvent==NULL ||m_OverlappedWrite.hEvent==NULL)   
	{   
		DWORD dwError=GetLastError();   
		if(m_OverlappedRead.hEvent!=NULL)
			CloseHandle(m_OverlappedRead.hEvent);   
		if(m_OverlappedWrite.hEvent!=NULL)   
			CloseHandle(m_OverlappedWrite.hEvent);   
		CloseHandle(m_hIDComDev);   
		return FALSE;   
	}   
    
	m_bOpened=TRUE;   
    
	return m_bOpened;   
}   

BOOL CSerial::Close(void)   
{   
	if(!m_bOpened || m_hIDComDev==NULL)   
		return TRUE;   
    
	if(m_OverlappedRead.hEvent!=NULL)   
		CloseHandle(m_OverlappedRead.hEvent);   
    
	if(m_OverlappedWrite.hEvent!=NULL)
		CloseHandle(m_OverlappedWrite.hEvent);   
    
	CloseHandle(m_hIDComDev);   
	m_bOpened=FALSE;   
	m_hIDComDev=NULL;   
	return TRUE;   
}   

BOOL CSerial::WriteCommByte(unsigned char ucByte)   
{   
	BOOL   bWriteStat;   
	DWORD   dwBytesWritten;   
    
	bWriteStat=WriteFile(m_hIDComDev,(LPSTR)&ucByte,1,&dwBytesWritten,&m_OverlappedWrite);   
    
	if(!bWriteStat && (GetLastError()==ERROR_IO_PENDING))   
	{   
		if(WaitForSingleObject(m_OverlappedWrite.hEvent,1000))   
			dwBytesWritten=0;   
		else   
		{   
			GetOverlappedResult(m_hIDComDev,&m_OverlappedWrite,&dwBytesWritten,FALSE);   
			m_OverlappedWrite.Offset+= dwBytesWritten;   
		}   
	}   
	return TRUE;   
}   

int CSerial::SendData(const char *buffer,int size)   
{   
	if(!m_bOpened || m_hIDComDev==NULL)   
		return 0;    
	DWORD dwBytesWritten=0;   
	int i;   
	for(i=0;i<size;i++)   
	{   
		WriteCommByte(buffer[i]);   
		dwBytesWritten++;   
	}   
    
	return (int)dwBytesWritten;   
}   

int CSerial::ReadDataWaiting(void)   
{   
	if(!m_bOpened ||m_hIDComDev== NULL)   
		return 0;   
    
	DWORD dwErrorFlags;   
	COMSTAT ComStat;   
    
	ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat);   
    
	return (int)ComStat.cbInQue;   
}   

int CSerial::ReadData(void *buffer,int limit)   
{   
	if(!m_bOpened || m_hIDComDev==NULL)   
		return 0;   
    
	BOOL bReadStatus;   
	DWORD dwBytesRead,dwErrorFlags;   
	COMSTAT ComStat;   
    
	ClearCommError(m_hIDComDev,&dwErrorFlags,&ComStat);   
    
	if(!ComStat.cbInQue)   
		return 0;   
    
	dwBytesRead=(DWORD)ComStat.cbInQue;   
    
	if(limit<(int)dwBytesRead)   
		dwBytesRead=(DWORD)limit;   
    
	bReadStatus=ReadFile(m_hIDComDev,buffer,dwBytesRead,&dwBytesRead,&m_OverlappedRead);   
    
	if(!bReadStatus)   
	{   
		if(GetLastError()==ERROR_IO_PENDING)   
		{   
			WaitForSingleObject(m_OverlappedRead.hEvent,2000);   
			return (int)dwBytesRead;   
		}   
		return 0;   
	}   
    
	return (int)dwBytesRead;   
}   

[ccing]

请问楼主是用VC6.0开发，还是其他的的编译器？