求教!串口通信

[llb2000]

用pc机与单片机通过串口实现多机通信,请问怎么实现软件握手协议?
还有,我发一条地址桢后,相应的单片机回发确认数据如0xaa,
我如何读取这一个字符?

[zzh]

通过对数据进行打包，比如每512个字节这一包或者每1024个字节为一个包，分为包头包尾，可以使用0x01或0x02这种特殊字符来充当包头或包尾，但对于在数据当的字符，必须转译，可以使用两个0x01来代替。这样就不会出错了。

[kaoms]

可以采用一个二进制序列来控制

[neomeng]

协议要自己定啊。

[mlike]

现在一般的书上都有，软件握手协议一般是自己定的。

[llb2000]

我的意思是这样的,pc发了地址桢给单片机后,单片机确认后给pc发一个0xaa表示确认,问题就是我用ReadFile函数如何读啊,书上说如果串口有足够的数据填充请求的缓冲区,则函数会立即返回,而且能够马上使用数据,但如果不能填充,就会开始异步读操作,我现在给的缓冲区肯定不止一个字节,那ReadFile函数会怎么运行?结果呢>

[steventt]

你可以设置事件，次事件就是EV_RXCHAR（接收到任何字符并放进缓冲区中），当有字符收到时，立即启动ReadFile();

[ximuwa]

非常关注！

[llb2000]

我现在这个问题还没解决,程序如下,问题是不管如何设置,ReadFile总是返回true,让我的阻塞语句毫无用处,简直快疯了,程序如下,麻烦大虾帮忙看看,多谢
UINT ComInputThread(void *arglist)
{
CRecSenior *port = (CRecSenior*) arglist;

OVERLAPPED AsyncReadInfo = {0};
OVERLAPPED AsyncStatusInfo = {0};
AsyncReadInfo.hEvent = CreateEvent(NULL,true,false,NULL);
AsyncStatusInfo.hEvent = CreateEvent(NULL,true,false,NULL);
assert( AsyncReadInfo.hEvent );
assert( AsyncStatusInfo.hEvent );

DWORD dwCommEvent;
bool waiting_on_status = false;
port->m_bInputThreadReading = false;

port->clear_error();

HANDLE handles[4] = {
port->m_hKillInputThreadEvent,
AsyncReadInfo.hEvent,
AsyncStatusInfo.hEvent,
port->m_hReadRequestEvent};

SetCommMask( port->m_hPort,
EV_BREAK | EV_CTS | EV_DSR | EV_RXCHAR |
EV_ERR | EV_RING | EV_RLSD | EV_TXEMPTY );

for ( bool done = false ; !done ; )
{
int bytes_to_read = 0;
char read_buffer[ 256 ];
DWORD dwBytesRead;
if ( !port->m_bInputThreadReading )
{
bytes_to_read = port->m_RxQueue.SpaceFree();
if ( bytes_to_read > 256 )
bytes_to_read = 256;

if (bytes_to_read >0)
{
if(!ReadFile(port->m_hPort,
read_buffer,
bytes_to_read,
&dwBytesRead,
&AsyncReadInfo))
{
port->m_bInputThreadReading = true;
}
else
{
if( dwBytesRead)
{
port->m_RxQueue.Insert(read_buffer,dwBytesRead);
}
}
}
else
{
ResetEvent( AsyncReadInfo.hEvent );
}
}

if ( !waiting_on_status )
{
if ( !WaitCommEvent( port->m_hPort,
&dwCommEvent,
&AsyncStatusInfo ) )
waiting_on_status = true;
port->clear_error();
}

if ( waiting_on_status &&
( port->m_bInputThreadReading || bytes_to_read == 0 ) )
{
DWORD result = WaitForMultipleObjects( 4,
handles,
FALSE,
INFINITE );
switch(result)
{
case 0://m_hKillInputThreadEvent
done = true;
break;
case 1://AsyncReadInfo.hEvent
if ( GetOverlappedResult( port->m_hPort,
&AsyncReadInfo,
&dwBytesRead,
false ) )
{
if ( dwBytesRead )
{
port->m_RxQueue.Insert( read_buffer, dwBytesRead );
}
}
port->m_bInputThreadReading = false;
// SetEvent(port->m_hDataProcessEvent);
break;
case 2://AsyncStatusInfo.hEvent
DWORD dwOverlappedResult;
if ( GetOverlappedResult( port->m_hPort,
&AsyncStatusInfo,
&dwOverlappedResult,
false ) )
port->clear_error();
waiting_on_status = false;
break;
case 3 :
break;
default :
done = true;
// assert( false );
}
}
}

CloseHandle(AsyncReadInfo.hEvent);
CloseHandle(AsyncStatusInfo.hEvent);

SetEvent(port->m_hInputThreadKilledEvent);

return 0;

}