串口编程的问题,(急)

[sky]

用API开发串口通讯程序:作了两个函数,

1:初始化函数:内容如下

//定义全局变量

HANDLE hCom; //准备打开的串口的句柄
OVERLAPPED Overlapped;

//打开串口，设置串口

hCom =CreateFile("COM1",GENERIC_READ|GENERIC_WRITE, //允许读写
0,//此项必须为0,不可共享
NULL, //不可被继承
OPEN_EXISTING, //设置产生方式
FILE_FLAG_OVERLAPPED, //准备使用异步通信
NULL);
}

SetCommMask(hCom, EV_RXCHAR|EV_TXEMPTY );//设置事件驱动的类型

//EV_RXCHAR: 接收到一个字节，并放入输入缓冲区
//EV_TXEMPTY:输出缓冲区中的最后一个字符，发送出去

SetupComm( hCom, 1024,512) ; //设置输入、输出缓冲区的大小

PurgeComm( hCom, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR
| PURGE_RXCLEAR ); //清干净输入、输出缓冲区

COMMTIMEOUTS CommTimeOuts ; //定义超时结构，并填写该结构

SetCommTimeouts( hCom, &CommTimeOuts ) ;//设置读写操作所允许的超时

DCB dcb ; // 定义数据控制块结构

GetCommState(hCom, &dcb ) ; //读串口原来的参数设置

dcb.BaudRate=9600; //波特率
dcb.ByteSize=8;
//一个字节的长度为8
dcb.Parity=NOPARITY;
// 04=no,odd,even,mark,space
dcb.StopBits=ONESTOPBIT; //一个停止位
dcb.fBinary=TRUE; //二进制传送
dcb.fParity=FALSE; //无奇偶校验
SetCommState(hCom, &dcb ) ; //串口参数配置

初始化完成后,测试证明初始化无错误,之后作发送数据测试,代码如下:


PurgeComm( hCom, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR
| PURGE_RXCLEAR ); //先清干净输入、输出缓冲区

BOOL fWriteStat ;
byte dat=66; //要发送的数据

fWriteStat = WriteFile( hCom,

&dat,

1,

NULL,

Overlapped); //写数据


执行发送之后为什么fWriteStat返回的值总是0，为什么发送不成功，请教各位了！

[spwnihao]

up

[WalkWorld]

debug

[zyleon]

gz

[uniware]

不是异步通讯吗，取出错误号看看是不是“重叠IO正在进行”一类的
建议好好看看MSDN或参考书

[caojianye]

当然写入不成功了！
WriteFile()的参数中，第四个实际写入的数据，你设置为NULL。
NULL 后，程序没得做的了。
应该是个变量由,系统返回。

[i_tingfeng]

BOOL NEAR CSerialToolDoc::WriteCommBlock(LPSTR lpByte, DWORD dwBytesToWrite)
{
BOOL fWriteState;
DWORD dwBytesWritten;
DWORD dwErrorFlags;
DWORD dwError;
COMSTAT ComStat;
if(!COMDEV(npGPSInfo)) return FALSE;
fWriteState = WriteFile(COMDEV(npGPSInfo),lpByte,dwBytesToWrite,&dwBytesWritten,&WRITE_OS(npGPSInfo));
if(!fWriteState){
if(GetLastError()==ERROR_IO_PENDING){
while(!GetOverlappedResult(COMDEV(npGPSInfo),&WRITE_OS(npGPSInfo),&dwBytesWritten,TRUE)){
dwError = GetLastError();
if(dwError==ERROR_IO_INCOMPLETE) continue;
else{
ClearCommError(COMDEV(npGPSInfo),&dwErrorFlags,&ComStat);
break;
}
}
}else{
ClearCommError(COMDEV(npGPSInfo),&dwErrorFlags,&ComStat);
return FALSE;
}
}
return TRUE;
}

[zjp899]

BOOL CComm::OpenConnection( LPCSTR lpszCommPort )
{
COMSTAT ComStat;
DWORD dwErrorFlags;

CString szCommPort = lpszCommPort;

m_hComm = CreateFile( szCommPort.Left(4),
GENERIC_READ | GENERIC_WRITE,
0, // exclusive access
NULL, // no security attrs
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, // overlapped I/O
NULL );

if (m_hComm == INVALID_HANDLE_VALUE )
return FALSE;

int r = SetupComm( INQUELEN, OUTQUELEN );

PurgeComm( PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );

// set up for overlapped I/O TotalTimeout = TimeoutMultiplier * nByteToReadOrWrite + TimeoutConstant
COMMTIMEOUTS CommTimeOuts;
CommTimeOuts.ReadIntervalTimeout = 250;
CommTimeOuts.ReadTotalTimeoutMultiplier = 10;
CommTimeOuts.ReadTotalTimeoutConstant = 1000;
CommTimeOuts.WriteTotalTimeoutMultiplier = 10;
CommTimeOuts.WriteTotalTimeoutConstant = 1000;
SetCommTimeouts( &CommTimeOuts );

if( ! SetupConnection( lpszCommPort ) )
{
CloseHandle( m_hComm );
m_hComm = INVALID_HANDLE_VALUE;
return FALSE;
}

ClearCommError( &dwErrorFlags, &ComStat );

m_bConnected = TRUE;
return TRUE;
}

void CComm::CloseConnection()
{
if ( IsConnected() )
{
m_bConnected = FALSE;

PurgeComm( PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );

CloseHandle( m_hComm );
m_hComm = INVALID_HANDLE_VALUE;
}
}

BOOL CComm::SetupConnection( LPCSTR lpszDef )
{
DCB dcb;

dcb.DCBlength = sizeof( DCB );

GetCommState( &dcb );
if( lpszDef == NULL || !BuildCommDCB( lpszDef, &dcb ) )
{
GetCommState( &dcb );
dcb.BaudRate = 1200;
dcb.ByteSize = 8;
dcb.Parity = ODDPARITY;
dcb.StopBits = ONESTOPBIT;
}
dcb.fBinary = TRUE;
dcb.fParity = TRUE;

dcb.fOutxDsrFlow = dcb.fOutxCtsFlow = FALSE ;
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
dcb.fInX = dcb.fOutX = FALSE;

dcb.fDsrSensitivity = FALSE;
dcb.fNull = FALSE;
dcb.fAbortOnError = FALSE;

return SetCommState( &dcb );
}

//////////////////////////////////////////////////////////////
int CComm::RecvComm(void* lpBuf, int nBufLen)
{
COMSTAT ComStat;
DWORD dwErrorFlags;
DWORD dwLength = 0;
OVERLAPPED os = {0, 0, 0, 0, NULL};

if ( !IsConnected() )
return FALSE ;

ClearCommError( &dwErrorFlags, &ComStat );
if ( dwErrorFlags != 0 )
{
PurgeComm( PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
return FALSE;
}

if ( ComStat.cbInQue < (DWORD)nBufLen)
return FALSE;

os.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
if( os.hEvent == NULL )
{
TRACE("\nFailed to create event for read!\n");
return FALSE;
}

if ( ! ReadFile( m_hComm, lpBuf, nBufLen, &dwLength, &os ) )
{
dwErrorFlags = ::GetLastError();
if( dwErrorFlags != ERROR_IO_PENDING)
{
TRACE("\nReadComm Error(%u)!\n", dwErrorFlags);
ClearCommError( &dwErrorFlags, &ComStat );
CloseHandle( os.hEvent ) ;
return FALSE;
}

while(!::GetOverlappedResult( m_hComm, &os, &dwLength, TRUE ))
{
//等待读出指定字节数或超时或出错
dwErrorFlags = ::GetLastError();
if( dwErrorFlags != ERROR_IO_INCOMPLETE )
{
TRACE("\nReadComm Error(%u)!\n", dwErrorFlags );
ClearCommError( &dwErrorFlags, &ComStat );
CloseHandle( os.hEvent ) ;
return FALSE;
}
}
}

//写入测试缓冲区
static int p = 0;
BYTE * Temp = (BYTE *)lpBuf;

if (m_pDoc ->m_TestFlag == TRUE)
{
for ( DWORD i=0; i<dwLength; i++ )
{
m_pDoc->m_RecvBuf[p++] = *Temp++;
if ( p >= 200 )
p = 0;
}
}

CloseHandle( os.hEvent ) ;
return dwLength;
}


int CComm::SendComm(const void * lpBuf, int nBufLen)
{
DWORD dwLength;
DWORD dwErrorFlags;
COMSTAT ComStat;
OVERLAPPED os = {0, 0, 0, 0, NULL};

if ( !IsConnected() )
return FALSE;

ClearCommError( &dwErrorFlags, &ComStat );
if ( dwErrorFlags > 0 )
{
PurgeComm( PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
return FALSE;
}

if ( (OUTQUELEN - ComStat.cbOutQue) < (DWORD)nBufLen)
return FALSE;

os.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
if ( os.hEvent == NULL )
{
TRACE("\nFailed to create event for write!\n");
return FALSE;
}

if ( ! WriteFile( m_hComm, lpBuf, nBufLen, &dwLength, &os ) )
{
dwErrorFlags = ::GetLastError();
if( dwErrorFlags != ERROR_IO_PENDING)
{
TRACE("\nSendComm Error(%u)!\n", dwErrorFlags );
ClearCommError( &dwErrorFlags, &ComStat );
CloseHandle( os.hEvent ) ;
return FALSE;
}

while( ! GetOverlappedResult( m_hComm, &os, &dwLength, TRUE ))
{
//等待写完指定字节数或超时或出错
dwErrorFlags = GetLastError();
if( dwErrorFlags != ERROR_IO_INCOMPLETE )
{
TRACE("\nSendComm Error(%u)!\n", dwErrorFlags );
ClearCommError( &dwErrorFlags, &ComStat );
CloseHandle( os.hEvent ) ;
return FALSE;
}
}
}

CloseHandle( os.hEvent ) ;

//写入测试缓冲区
static int p = 0;
BYTE * Temp = (BYTE *)lpBuf;

if (m_pDoc ->m_TestFlag == TRUE)
{
for ( DWORD i=0; i<dwLength; i++ )
{
m_pDoc->m_SendBuf[p++] = *Temp++;
if ( p >= 200 )
p = 0;
}
}

return dwLength;
}