[转]WinXP与WinCE串口的运行机制之比较

五香花生米

于 2013-04-26 16:16:08 发布

阅读量630

点赞数

分类专栏： MFC& 界面 VC

MFC& 界面同时被 2 个专栏收录

42 篇文章 0 订阅

订阅专栏

16 篇文章 0 订阅

订阅专栏

//========================================================================
//TITLE:
//    WinXP与WinCE串口的运行机制之比较
//AUTHOR:
//    norains
//DATE:
//    Saturday  11-November-2006
//Passed Environment:
//    PC:WinXP+VC6.0
//    CE:WinCE4.2+EVC4.0
//========================================================================

    查看微软相关的串口通信文档,可以发现在桌面操作系统中,串口通信分为两种模式:同步和异步.而WinCE只有一种,但文档中却没标明归属哪种模式.实际上,WinCE的串口通信模式更像介于同步和异步之间.
    在此先简要地介绍何为同步和异步.所谓的同步,指得是对同一个设备或文件(在文中只的是串口COM1)的读或写操作必须要等待上一个操作完成才能进行.比如说,调用ReadFile()函数读取串口,但由于上一个WriteFile()操作没完成,ReadFile()的操作就被阻塞,直到 WriteFile()完成后才能运行.而异步,则无论上一个操作是否完成,都会执行目前调用的操作.还是拿前面举的例子,在异步模式下,即使 WriteFile()没有执行完成,ReadFile()也会立刻执行.


1.CreateFile()参数的差异
    首先说明一下WinCE和WinXP打开串口时参数的差异.以打开串口COM1为例子, WinCE下的名字为"COM1:",而WinXP为"COM1",两者的唯一区别仅仅在于WinCE下多个分号.
    例如:

1     HANDLE hd = CreateFile(TEXT("COM1:"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); //WinCE
2     HANDLE hd = CreateFile(TEXT("COM1"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); //WinXP

    在这稍微多说一下,在默认的环境下,TEXT宏在WinCE下会编译为双字节,而WinXP为单字节.换句话说,TEXT("COM1")在WinCE下相当于L"COM1",而WinXP则为"COM1".


2.单线程比较
   还是用代码做例子来说明比较形象.这是一段单线程的代码,先对串口进行写操作,然后再读.对于WinXP来说,这是同步模式.(与主题无关的代码省略)

 1 int WINAPI WinMain( HINSTANCE hInstance,
 2      HINSTANCE hPrevInstance,
 3      LPTSTR    lpCmdLine,
 4      int       nCmdShow)
 5 {
 6 　　...     
 7 　　HANDLE hCom = CreateFile(TEXT("COM1:"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); //WinCE
 8 　　//HANDLE Com = CreateFile(TEXT("COM1"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); //WinXP
 9 　　  
10 　　...
11 　　DWORD dwBytes;
12 　　if(WriteFile(hCom,TEXT("COM1:"),5,&dwBytes,NULL) == FALSE) //WinCE
13 　　//if(WriteFile(hCom,TEXT("COM1"),5,&dwBytes,NULL) == FALSE) //WinXP
14 　　{
15 　　　　return 0x05;
16 　　}
17      
18 　　...
19 　　DWORD dwRead;
20 　　char szBuf[MAX_READ_BUFFER];
21 　　if(ReadFile(hCom,szBuf,MAX_READ_BUFFER,&dwRead,NULL) == FALSE)
22 　　{
23 　　　　return 0x10;
24 　　}
25      
26 　　...
27 }

经过实验,可以发现这段代码在WinCE和WinXP下都能正常工作,并且其表现也相同,都是在WriteFile()函数返回后才执行ReadFile().
由于异步模式在单线程中也能正常运作,唯一的不同只是在执行WriteFile()时可能也会执行ReadFile()(依WriteFile()函数执行的时间而定),所在此不表.

3.多线程比较
    单线程两者表现相同,那多线程呢?下面这段代码采用多线程,先是创建一个读的线程,用来监控串口是否有新数据到达,然后在主线程中对串口写出数据.
    这里假设是这么一个情况,有两台设备,分别为A和B,下面的代码运行于设备A,设备B仅仅只是应答而已.换句话说,只有A向B发送数据,B才会返回应答信号.

 1 //主线程
 2 int WINAPI WinMain( HINSTANCE hInstance,
 3      HINSTANCE hPrevInstance,
 4      LPTSTR    lpCmdLine,
 5      int       nCmdShow)
 6 {
 7     ...
 8     CreateThread(NULL,0,ReadThread,0,0,&dwThrdID); //创建一个读的线程.
 9 
10     ...     
11     HANDLE hCom = CreateFile(TEXT("COM1:"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); //WinCE
12 　　//HANDLE Com = CreateFile(TEXT("COM1"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); //WinXP
13  
14     ...
15     DWORD dwBytes;
16     if(WriteFile(hCom,"AT/r/n",4,&dwBytes,NULL) == FALSE) //WinCE
17 　　//if(WriteFile(hCom,"AT/r/n",5,&dwBytes,NULL) == FALSE) //WinXP
18     {
19         return 0x05;
20     }
21  
22     ...
23     
24 }
25 
26 //读线程
27 DWORD WINAPI ReadThread()
28 {
29     ...
30     SetCommMask(hCom,EV_RXCHAR);
31     DWORD dwCommStatus = 0;
32     if(WaitCommEvent(hCom,&dwCommStatus,NULL) == FALSE)
33     {
34         //Clear the error flag
35         DWORD dwErrors;
36         COMSTAT comStat;
37         memset(&comStat,0,sizeof(comStat));
38         ClearCommError(hCom,&dwErrors,&comStat);
39         return 0x15;
40     }
41 
42     ...
43     char szBuf[MAX_READ_BUFFER]={0};
44     DWORD dwRead;
45     if(ReadFile(hCom,szBuf,MAX_READ_BUFFER,&dwRead,NULL) == FALSE || dwRead == 0)
46     {
47         return 0x20;
48     }
49 
50     ...
51 }

    这段代码在WinCE下运行完全正常,读线程在监听收到的数据的同时,主线程顺利地往外发数据.
    然而同样的代码,在WinXP下则根本无法完成工作.运行此代码,我们将发现CPU的占用率高达99%.通过单步调试,发现两个线程分别卡在 WaitCommEvent()和WriteFile()函数中.因为根据同步模式的定义,当前对设备的操作必须要等待上一个操作完毕方可执行.在以上代码中,因为设备B没接到设备A的命令而不会向设备A发送应答,故WaitCommEvent()函数因为没有检测到接受数据而一直在占用串口;而 WaitCommEvent()一直占据串口使得WriteFile()没有得到串口资源而处于阻塞状态,这就造成了死锁.
    而这种情况没有在WinCE上出现,只要WaitCommEvent()和WriteFile()不在同一个线程,就可以正常工作.这应该和系统的调度方式有关.

    如果要在PC上同时进行WaitCommEvent()和WriteFile()操作,需要把串口的模式改写为异步模式.
    更改后的代码如下:

 1 //主线程
 2 int WINAPI WinMain( HINSTANCE hInstance,
 3      HINSTANCE hPrevInstance,
 4      LPTSTR    lpCmdLine,
 5      int       nCmdShow)
 6 {
 7     ...
 8     CreateThread(NULL,0,ReadThread,0,0,&dwThrdID); //创建一个读的线程.
 9 
10     ...     
11     HANDLE Com = CreateFile(TEXT("COM1"),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,FILE_FLAG_OVERLAPPED);
12  
13     ...
14     OVERLAPPED olWrite;
15     memset(&olWrite,0,sizeof(m_olWrite));
16     olWrite.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
17 
18     DWORD dwBytes; 
19     if(WriteFile(hCom,"AT/r/n",4,&dwBytes,&olWrite) == FALSE)
20     {
21         if(GetLastError() != ERROR_IO_PENDING)
22         {
23             return 0x20;
24         }
25     }
26     if(GetOverlappedResult(hCom,&olWrite,&dwBytes,TRUE) == FALSE)
27     {
28         return 0x25;
29     }
30     ...
31 
32 }
33 
34 //读线程
35 DWORD WINAPI ReadThread()
36 {
37     ...     
38     memset(&olWaite,0,sizeof(olWaite)); 
39     olWaite.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);     
40     SetCommMask(hCom),EV_RXCHAR);
41     DWORD dwCommStatus = 0;
42     WaitCommEvent(hCom,&dwCommStatus,olWaite);
43     DWORD dwByte; //norains:It is only suitable for the GetOverlappedResult(),not undefined here.
44     if(GetOverlappedResult(hCom,olWaite,&dwByte,TRUE) == FALSE)
45     {
46         if(GetLastError() != ERROR_IO_PENDING)
47         {
48              return 0x30;
49         }
50         //Clear the error flag
51         DWORD dwErrors;
52         COMSTAT comStat;
53         memset(&comStat,0,sizeof(comStat));
54         ClearCommError(hCom,&dwErrors,&comStat);
55         return 0x35;
56     }
57 
58     ...
59     memset(&olRead,0,sizeof(olRead));
60     olRead.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
61     char szBuf[MAX_READ_BUFFER]={0};
62     DWORD dwRead;
63     if(ReadFile(hCom,szBuf,MAX_READ_BUFFER,&dwRead,olRead) ==FALSE)
64     {
65         if(GetLastError() != ERROR_IO_PENDING)
66         {
67             return 0x40;
68         }
69         if(GetOverlappedResult(hCom,olRead,&dwRead,TRUE) == FALSE)
70         {
71             return 0x45;
72         }
73         if(dwRead == 0)
74         {
75             return 0x50;
76         }
77     }
78 
79     ...
80 }

    测试经过更改后的代码,可以发现在WinXP下终于可以同时调用WaitCommEvent()和WriteFile()而不造成死锁.
    在这里可以发现WinCE和WinXP的串口调度的差异性:单线程中,WinCE的串口工作方式和WinXP串口的同步工作模式相符;而多线程中,WinCE串口工作方式却又和WinXP的异步方式吻合.虽然无法确切比较WinCE的单一串口模式是否比WinXP的双模式更为优越,但可以确认的是,WinCE的这种串口调用方式给程序员带来了极大的便利.


4.WinXP异步模式两种判断操作是否成功的方法
    因为在WinXP的异步模式中,WriteFile(),ReadFile()和WaitCommEvent()大部分情况下都是未操作完毕就返回,所以不能简单地判断返回值是否为TRUE或FALSE来判断.
    以ReadFile()函数做例子.
    一种是上文所用的方法:

 1 if(ReadFile(hCom,szBuf,MAX_READ_BUFFER,&dwRead,olRead) ==FALSE)
 2 {
 3     if(GetLastError() != ERROR_IO_PENDING)
 4     {
 5         return 0x40;
 6     }
 7     if(GetOverlappedResult(hCom,olRead,&dwRead,TRUE) == FALSE)
 8     {
 9         return 0x45;
10     }
11     if(dwRead == 0)
12     {
13         return 0x50;
14     }
15 }

    如果ReadFile()返回为TRUE,则表明读文件已经完成.但这种情况几乎不会出现,因为对外设的读写相对于内存的读写来说非常慢,所以一般在ReadFile()函数还没执行完毕,程序已经执行到下一个语句.
    当ReadFile()返回为FALSE时,需要采用GetLastError()函数判断读操作是否在后台进行.如果在后台进行,则调用 GetOverlappedResult()函数获取ReadFile()函数的结果.在这里要注意的是,GetOverlappedResult()函数的最后一个参数必须设置为TRUE,表明要等ReadFile()函数在后台运行完毕才返回.如果最后一个参数设置为FALSE,则即使 ReadFile()还在后台执行,GetOverlappedResult()函数也会立刻返回,从而造成判断错误.

    另一种是调用WaitForSingleObject函数达到此目的:

 1 if(ReadFile(hCom,szBuf,MAX_READ_BUFFER,&dwRead,olRead) ==FALSE)
 2 {
 3     if(GetLastError() != ERROR_IO_PENDING)
 4     {
 5         return 0x40;
 6     }
 7     if(WaitForSingleObject(olRead.hEvent,INFINITE) != WAIT_OBJECT_0)
 8     {
 9         return 0x55;
10     } 
11     if(GetOverlappedResult(hCom,olRead,&dwRead,FALSE) == FALSE)
12     {
13         return 0x45;
14     }
15     if(dwRead == 0)
16     {
17         return 0x50;
18     }
19 }

因为ReadFile()在后台执行完毕以后,会发送一个event,所以在这里可以调用WaitForSingleObject()等待 ReadFile()执行完毕,然后再调用GetOverlappedResult()获取ReadFile()的最终结果.在这里需要注意的是,GetOverlappedResult()的最后一个参数一定要设置为FALSE,因为WaitForSingleObject()已经捕获了 ReadFile()发出的event,再也没有event传递到GetOverlappedResult()函数.如果此时 GetOverlappedResult()最后一个参数设置为TRUE,则线程会一直停留在GetOverlappedResult()函数而不往下执行.

来源：http://blog.csdn.net/ceFighter/article/details/5532878

五香花生米

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[转]WinXP与WinCE串口的运行机制之比较

//========================================================================//TITLE:// WinXP与WinCE串口的运行机制之比较//AUTHOR:// norains//DATE:// Saturday 11-November-2006//Passed Environment:// PC:
复制链接

扫一扫

专栏目录