QNX下三类定时器的C++封装

QNX下存在三类定时器，使用的难易程度不一样，精度也不一样。分别对其进行了一下封装，使用起来相对简单一点。
一、PtTimer

PtTimer是三者之中使用起来最简单的，但性能也最差，不过它与Rttimer一样，可以直接操作GUI里面的函数，相比HardTimer就不行了。

1. // QnxPtTimer.h: interface for the CQnxPtTimer class. 
2. // 
3. ////////////////////////////////////////////////////////////////////// 
5. #if !defined(AFX_QNXPTTIMER_H__01609CA6_BF75_4F50_93B6_BF323F927AB6__INCLUDED_) 
6. #define AFX_QNXPTTIMER_H__01609CA6_BF75_4F50_93B6_BF323F927AB6__INCLUDED_ 
8. /*这个类基于PtTimer控间，存在一些实时性的不足。如英文描述。
9. PtTimer is easy to use, but doesn't give accurate timer events. In particular, 
10. it doesn't guarantee a constant repeat rate; since the repetition is handled by rearming 
11. the timer for each event, any delays in handling the events accumulate. Kernel timers 
12. guarantee an accurate repeat rate even if your application can't keep up with them. 
13. */
16. #if _MSC_VER > 1000 
17. #pragma once 
18. #endif // _MSC_VER > 1000 
19. #include  
20. #include  
21. #include  
23. //毫秒为单位 
24. class CQnxPtTimer  
25. {
26. public:
27.     CQnxPtTimer(unsigned long init=1,//开始时间 
28.         unsigned long repeat=500,//重复周期 
29.         bool iAutoStart=0/*是否自动启动，1自动启动，0手动启动*/);
31.     virtual ~CQnxPtTimer();
32. private:
33.     void CreatePareantWin();
34. public:
35.     void SetInitTime(unsigned long init);
36.     void SetRepeatTime(unsigned long repeat);
37.     
38.     void StartTimer();
39.     void StopTimer();
41.     int  SetPtTimerParent(PtWidget_t* pParent); 
43. public:
44.     PtWidget_t *GetTimer();
45.     unsigned long GetInitTime();
46.     unsigned long GetRepeatTime();
48. public:
49.     static int Cb_Timer( PtWidget_t *widget, void *data,  PtCallbackInfo_t *cbinfo );
50.     
51. public:
52.     virtual void RepeatTimerThread();
54.     void SetTimerPareant(PtWidget_t *pParent);
55. protected:
56.     PtWidget_t  *m_pPareantWin;
57.     PtWidget_t  *m_pPtTimer;
59.     //The time, in milliseconds: 
60.     unsigned long m_InitTime;   //The time,before the first timer callback is activated 
61.     unsigned long m_RepeatTime; //The time, for the repeat rate of the timer once the initial time period has expired.  
63. };
65. #endif // !defined(AFX_QNXPTTIMER_H__01609CA6_BF75_4F50_93B6_BF323F927AB6__INCLUDED_) 
68. // QnxPtTimer.cpp: implementation of the CQnxPtTimer class. 
69. // 
70. ////////////////////////////////////////////////////////////////////// 
72. #include "QnxPtTimer.h" 
73. ////////////////////////////////////////////////////////////////////// 
74. // Construction/Destruction 
75. ////////////////////////////////////////////////////////////////////// 
76. CQnxPtTimer::CQnxPtTimer(unsigned long init,unsigned long repeat,bool iAutoStart)
77. {
78.     m_pPtTimer=NULL;
79.     CreatePareantWin();
80.     m_pPtTimer=PtCreateWidget(PtTimer,m_pPareantWin,0,NULL);
81.     SetInitTime(init);
82.     SetRepeatTime(repeat);
83.     PtAddCallback(m_pPtTimer, Pt_CB_TIMER_ACTIVATE,Cb_Timer, this );    
85.     if(iAutoStart)
86.     {
87.         StartTimer();
88.     }
90. }
92. CQnxPtTimer::~CQnxPtTimer()
93. {
94.     PtUnrealizeWidget(m_pPareantWin);
95. }
97. void CQnxPtTimer::SetTimerPareant(PtWidget_t *pParent)
98. {
99.     if (m_pPtTimer)
100.     {
101.         m_pPareantWin=pParent;
102.         PtReparentWidget(m_pPtTimer,m_pPareantWin);
103.     }
104. }
106. void CQnxPtTimer::CreatePareantWin()
107. {
108.     m_pPareantWin=PtCreateWidget(PtWindow,Pt_NO_PARENT,0,NULL);
109.     PhPoint_t pos={-200,-200};
110.     PtSetResource(m_pPareantWin,Pt_ARG_POS,&pos,0);
111. }
113. void CQnxPtTimer::SetInitTime(unsigned long init)
114. {
115.     m_InitTime=init;
116.     if (m_pPtTimer)
117.     {
118.         PtSetResource(m_pPtTimer,Pt_ARG_TIMER_INITIAL,m_InitTime,0);
119.     }
120. }
122. void CQnxPtTimer::SetRepeatTime(unsigned long repeat)
123. {
124.     m_RepeatTime=repeat;
125.     if (m_pPtTimer)
126.     {
127.         PtSetResource(m_pPtTimer,Pt_ARG_TIMER_REPEAT,m_RepeatTime,0);
128.     }
129. }
130.     
131. void CQnxPtTimer::StartTimer()
132. {
133.     if (!m_pPtTimer)
134.     {
135.         return;
136.     }
137.     if (m_InitTime==0)
138.     {
139.         m_InitTime=500;
140.     }
141.     PtSetResource(m_pPtTimer,Pt_ARG_TIMER_INITIAL,m_InitTime,0);
142.     PtRealizeWidget(m_pPareantWin); 
143.     PtWindowToBack(m_pPareantWin);
144. }
145. void CQnxPtTimer::StopTimer()
146. {
147.     if (!m_pPtTimer)
148.     {
149.         return;
150.     }
151.     PtSetResource(m_pPtTimer,Pt_ARG_TIMER_INITIAL,0,0);
152. }
154. PtWidget_t *CQnxPtTimer::GetTimer()
155. {
156.     return m_pPtTimer;
157. }
159. unsigned long CQnxPtTimer::GetInitTime()
160. {
161.     return m_InitTime;
162. }
164. unsigned long CQnxPtTimer::GetRepeatTime()
165. {
166.     return m_RepeatTime;
167. }
169. int CQnxPtTimer::Cb_Timer( PtWidget_t *widget, void *data,  PtCallbackInfo_t *cbinfo )
170. {
171.     CQnxPtTimer *pPtTim=(CQnxPtTimer *)data;
172.     if (pPtTim!=NULL)
173.     {
174.         pPtTim->RepeatTimerThread();
175.     }
176.     return Pt_CONTINUE;
177. }
179. int  CQnxPtTimer::SetPtTimerParent(PtWidget_t* pParent)
180. {
181.     return PtReparentWidget( m_pPtTimer,pParent);
182. }   
184. void CQnxPtTimer::RepeatTimerThread()
185. {
186. //  printf("CQnxPtTimer::RepeatTimerThread/n"); 
187. }

二、Rttimer

1. // QnxRtTimer.h: interface for the CQnxRtTimer class.
2. //
3. //////////////////////////////////////////////////////////////////////
5. #if !defined(AFX_QNXRTTIMER_H__C504E91B_54FC_46D2_AE62_74CBE0AE5636__INCLUDED_)
6. #define AFX_QNXRTTIMER_H__C504E91B_54FC_46D2_AE62_74CBE0AE5636__INCLUDED_
8. #if _MSC_VER > 1000
9. #pragma once
10. #endif // _MSC_VER > 1000
11. #include 
12. #include 
13. #include 
15. class CQnxRtTimer  
16. {
17. public:
18.     CQnxRtTimer(unsigned long init=1,//开始时间
19.         unsigned long repeat=500,//重复周期
20.         bool iAutoStart=0/*是否自动启动，1自动启动，0手动启动*/);
21.     virtual ~CQnxRtTimer();
23. private:
24.     void    MyTimerCreate();
25.     unsigned long   GetTv_Sec(unsigned long imSec);//由毫秒转化为秒（不到一秒的舍去）
26.     unsigned long   GetTv_nSec(unsigned long imSec);//由毫秒转化为纳秒（只取不到一秒的毫秒部分）
28. public:
29.     void SetInitTime(unsigned long init);
30.     void SetRepeatTime(unsigned long repeat);
31.     
32.     void StartTimer();
33.     void StopTimer();
36. public:
37.     unsigned long GetInitTime();
38.     unsigned long GetRepeatTime();
40. public:
41.     static int Cb_RtTimer( RtTimer_t *timer, void *data);
43. public:
44.     virtual void RepeatTimerThread( );
46. protected:
47.     //The time, in milliseconds:
48.     unsigned long m_InitTime;   //The time,before the first timer callback is activated
49.     unsigned long m_RepeatTime; //The time, for the repeat rate of the timer once the initial time period has expired. 
50.     struct itimerspec m_itTimerSpec;
51.     RtTimer_t *   m_pRtTimer;
52. };
54. #endif // !defined(AFX_QNXRTTIMER_H__C504E91B_54FC_46D2_AE62_74CBE0AE5636__INCLUDED_)
56. // QnxRtTimer.cpp: implementation of the CQnxRtTimer class.
57. //
58. //////////////////////////////////////////////////////////////////////
60. #include "QnxRtTimer.h"
62. //////////////////////////////////////////////////////////////////////
63. // Construction/Destruction
64. //////////////////////////////////////////////////////////////////////
66. CQnxRtTimer::CQnxRtTimer(unsigned long init,unsigned long repeat,bool iAutoStart)
67. {
68.     m_InitTime=init;
69.     m_RepeatTime=repeat;
70.     m_pRtTimer=NULL;
71.     MyTimerCreate();
72.     if (iAutoStart)
73.     {
74.         StartTimer();
75.     }
76. }
78. CQnxRtTimer::~CQnxRtTimer()
79. {
81. }
83. void    CQnxRtTimer::MyTimerCreate()
84. {
85. //  printf("CQnxRtTimer::MyTimerCreate/n");
86.     m_pRtTimer=RtTimerCreate(CLOCK_REALTIME,-1,Cb_RtTimer,this);
87. }
89. //由毫秒转化为秒（不到一秒的舍去）
90. unsigned long   CQnxRtTimer::GetTv_Sec(unsigned long imSec)
91. {
92.     return (imSec/1000) ;
93. }
95. //由毫秒转化为纳秒（只取不到一秒的毫秒部分）
96. unsigned long   CQnxRtTimer::GetTv_nSec(unsigned long imSec)
97. {
98.     return (imSec%1000)*1000000;
99. }
101. void CQnxRtTimer::SetInitTime(unsigned long init)
102. {
103.     m_InitTime=init;
104. }
105. void CQnxRtTimer::SetRepeatTime(unsigned long repeat)
106. {
107.     m_RepeatTime=repeat;
108. }
110. void CQnxRtTimer::StartTimer()
111. {
112. //  printf("CQnxRtTimer::StartTimer/n");
113.     if (m_InitTime==0)//－－－－－－－－消除m_InitTime＝0对定时器启动的影响
114.     {
115.         m_InitTime=1;
116.     }
117.     /*
118.     struct timespec it_value 
119.     A timespec structure that contains the amount of time left before the timer expires, or zero if the timer is disarmed. This value is expressed as the relative interval until expiration, even if the timer was armed with an absolute time. 
120.     struct timespec it_interval 
121.     A timespec structure that contains the timer's reload value. If nonzero, it indicates a repetitive timer period. 
122.     */
123.     // Set the timer to trigger every repeat msec
124.     m_itTimerSpec.it_value.tv_sec = GetTv_Sec(m_InitTime); 
125.     m_itTimerSpec.it_value.tv_nsec = GetTv_nSec(m_InitTime); 
126.     m_itTimerSpec.it_interval.tv_sec = GetTv_Sec(m_RepeatTime);
127.     m_itTimerSpec.it_interval.tv_nsec =GetTv_nSec(m_RepeatTime); 
128.     // Activate the timer
129.     RtTimerSetTime(m_pRtTimer, 0,  &m_itTimerSpec, NULL);
131. }
132. void CQnxRtTimer::StopTimer()
133. {
134.     // 
135.     m_itTimerSpec.it_value.tv_sec = 0; 
136.     m_itTimerSpec.it_value.tv_nsec =0; 
137.     RtTimerSetTime(m_pRtTimer, 0,  &m_itTimerSpec, NULL);
138. }
141. unsigned long CQnxRtTimer::GetInitTime()
142. {
143.     return m_InitTime;
144. }
145. unsigned long CQnxRtTimer::GetRepeatTime()
146. {
147.     return  m_RepeatTime;
148. }
152. int CQnxRtTimer::Cb_RtTimer( RtTimer_t *timer, void *data)
153. {
154. //  printf("CQnxRtTimer::Cb_RtTimer/n");
155.     CQnxRtTimer *pRttimer=(CQnxRtTimer *)data;
156.     if (!pRttimer)
157.     {
158.         return Pt_CONTINUE;
159.     }
160.     pRttimer->RepeatTimerThread();
161.     return Pt_CONTINUE;
162. }
164. void CQnxRtTimer::RepeatTimerThread( )
165. {
166. //  printf("CQnxRtTimer::RepeatTimerThread/n");
167. }

3、HardTimer

 

 

1. // QnxHardTimer.h: interface for the CQnxHardTimer class.
2. //
3. //////////////////////////////////////////////////////////////////////
5. /******************************************************************************
6.     Timers in a separate process from the GUI -- necessary for hard realtime
7.     毫秒为单位
8.     注意，这个线程与Photon GUI是独立的，在这个定时器线程里不能够直接操作GUI
9. 界面程序里的资源，必须使用PtEnter等API，可参考“Parallel Operations”一章
10. 里的描述。如下是使用中的一个示例：
11.     int eval;
12.     if ((eval = PtEnter(0)) < 0 && eval != -EDEADLK){
13.       fprintf( stderr, "Couldn't enter: %s/n", strerror( -eval ) );
14.     }else{
15.         //操作Photon GUI资源，如：
16.         PtSetResource(g_pProgress,Pt_ARG_GAUGE_VALUE ,iCount,0);
17.         //操作完毕离开
18.         PtLeave(eval);  // does nothing if eval == -EDEADLK
19.     }   
20.     该定时器封装为以毫秒为单位，可以满足一般的程序设计需要。如果需要更高
21. 精度的定时器，只需简单更改构造函数部分。                                
22. ******************************************************************************/
23. #if !defined(AFX_QNXHARDTIMER_H__B6E1FA73_C325_4A30_8F2E_67891C02BC1B__INCLUDED_)
24. #define AFX_QNXHARDTIMER_H__B6E1FA73_C325_4A30_8F2E_67891C02BC1B__INCLUDED_
26. #if _MSC_VER > 1000
27. #pragma once
28. #endif // _MSC_VER > 1000
30. #include 
31. #include 
32. #include 
33. #include 
37. // Define the codes for the pulses
38. #define PULSE_HARDTIMER         _PULSE_CODE_MINAVAIL
39. #define PULSE_EXIT              _PULSE_CODE_MINAVAIL + 1
42. typedef union {
43.         struct _pulse   pulse;
44.         /* your other message structures would go here too,此处不需要 */
45. } _THREAD_MESSAGE;
48. class CQnxHardTimer  
49. {
50. public:
51.     CQnxHardTimer(unsigned long init=1,//开始时间
52.         unsigned long repeat=500,//重复周期
53.         bool iAutoStart=0/*是否自动启动，1自动启动，0手动启动*/);
54.     virtual ~CQnxHardTimer();
56. private:
57.     void    TimerThreadCreate();
58.     unsigned long   GetTv_Sec(unsigned long imSec);//由毫秒转化为秒（不到一秒的舍去）
59.     unsigned long   GetTv_nSec(unsigned long imSec);//由毫秒转化为纳秒（只取不到一秒的毫秒部分）
61. public:
62.     void SetInitTime(unsigned long init);
63.     void SetRepeatTime(unsigned long repeat);
64.     
65.     void StartTimer();
66.     void StopTimer();
68.     void ExitTimerThread();
70. public:
71.     unsigned long GetInitTime();
72.     unsigned long GetRepeatTime();
74. public:
75.     static void*  _PeriodicThread(void *vArguments);
77.     
78. public:
79.     virtual void  RepeatTimerThread();
81. protected:
82.     //The time, in milliseconds:
83.     unsigned long m_InitTime;   //The time,before the first timer callback is activated
84.     unsigned long m_RepeatTime; //The time, for the repeat rate of the timer once the initial time period has expired. 
85.     int           m_iTimerChannel;
86.     struct itimerspec m_itTimerSpec;
87.     timer_t           m_TimerId;
88.     //PC定时器用到的变量
89.     struct sigevent  m_seEvent;
91. };
93. #endif // !defined(AFX_QNXHARDTIMER_H__B6E1FA73_C325_4A30_8F2E_67891C02BC1B__INCLUDED_)
95. // QnxHardTimer.cpp: implementation of the CQnxHardTimer class.
96. //
97. //////////////////////////////////////////////////////////////////////
99. #include "QnxHardTimer.h"
100. //#include 
101. //////////////////////////////////////////////////////////////////////
102. // Construction/Destruction
103. //////////////////////////////////////////////////////////////////////
105. CQnxHardTimer::CQnxHardTimer(unsigned long init,unsigned long repeat,bool iAutoStart)
106. {
107.     m_InitTime=init;
108.     m_RepeatTime=repeat;
109.     TimerThreadCreate();
110.     if (iAutoStart)
111.     {
112.         StartTimer();
113.     }
114. }
116. CQnxHardTimer::~CQnxHardTimer()
117. {
119. }
120. void    CQnxHardTimer::TimerThreadCreate()
121. {
122.     
123.     pthread_t ptThread;         //定时器线程
124.     pthread_attr_t ptaThreadAttributes;
126.     m_iTimerChannel = ChannelCreate(0);
127.     // Set the timer to send a pulse with the value PULSE_HARDTIMER when triggered
128.     m_seEvent.sigev_notify = SIGEV_PULSE;
129.     m_seEvent.sigev_coid = ConnectAttach(ND_LOCAL_NODE, 0, m_iTimerChannel, _NTO_SIDE_CHANNEL, 0);
130.     m_seEvent.sigev_priority = getprio(0);
131.     m_seEvent.sigev_code = PULSE_HARDTIMER;
132.     timer_create(CLOCK_REALTIME, &m_seEvent, &m_TimerId);
133.     // Create the thread and make it detached - no need to call join or cancel
134.     pthread_attr_init( &ptaThreadAttributes );
135.     pthread_attr_setdetachstate(&ptaThreadAttributes, PTHREAD_CREATE_DETACHED );
136.     pthread_create(&ptThread, &ptaThreadAttributes, &_PeriodicThread, this );
137. }
139. //由毫秒转化为秒（不到一秒的舍去）
140. unsigned long   CQnxHardTimer::GetTv_Sec(unsigned long imSec)
141. {
142.     return (imSec/1000) ;
143. }
145. //由毫秒转化为纳秒（只取不到一秒的毫秒部分）
146. unsigned long   CQnxHardTimer::GetTv_nSec(unsigned long imSec)
147. {
148.     return (imSec%1000)*1000000;
149. }
151. void CQnxHardTimer::SetInitTime(unsigned long init)
152. {
153.     m_InitTime=init;
154. }
155. void CQnxHardTimer::SetRepeatTime(unsigned long repeat)
156. {
157.     m_RepeatTime=repeat;
158. }
160. void CQnxHardTimer::StartTimer()
161. {
162.     if (m_InitTime==0)//－－－－－－－－消除m_InitTime＝0对定时器启动的影响
163.     {
164.         m_InitTime=1;
165.     }
166.     /*
167.     struct timespec it_value 
168.     A timespec structure that contains the amount of time left before the timer expires, or zero if the timer is disarmed. This value is expressed as the relative interval until expiration, even if the timer was armed with an absolute time. 
169.     struct timespec it_interval 
170.     A timespec structure that contains the timer's reload value. If nonzero, it indicates a repetitive timer period. 
171.     */
172.     // Set the timer to trigger every repeat msec
173.     m_itTimerSpec.it_value.tv_sec = GetTv_Sec(m_InitTime); 
174.     m_itTimerSpec.it_value.tv_nsec = GetTv_nSec(m_InitTime); 
175.     m_itTimerSpec.it_interval.tv_sec = GetTv_Sec(m_RepeatTime);
176.     m_itTimerSpec.it_interval.tv_nsec =GetTv_nSec(m_RepeatTime); 
177.     // Activate the timer
178.     timer_settime(m_TimerId, 0,  &m_itTimerSpec, NULL);
180. }
181. void CQnxHardTimer::StopTimer()
182. {
183.     // 
184.     m_itTimerSpec.it_value.tv_sec = 0; 
185.     m_itTimerSpec.it_value.tv_nsec =0; 
186. //  m_itTimerSpec.it_interval.tv_sec = GetTv_Sec(m_RepeatTime);
187. //  m_itTimerSpec.it_interval.tv_nsec =GetTv_nSec(m_RepeatTime); 
188.     // Activate the timer
189.     timer_settime(m_TimerId, 0,  &m_itTimerSpec, NULL);
190. }
192. //
193. void CQnxHardTimer::ExitTimerThread()
194. {
195.     // Send the destruct message
196.     MsgSendPulse(m_seEvent.sigev_coid, 1, PULSE_EXIT, PULSE_EXIT);
197. }
200. unsigned long CQnxHardTimer::GetInitTime()
201. {
202.     return m_InitTime;
203. }
204. unsigned long CQnxHardTimer::GetRepeatTime()
205. {
206.     return  m_RepeatTime;
207. }
210. /*
211.  * Function:     _PeriodicThread      
212.  * Description:  定时器定时产生一个pulse，该线程就是捕捉该周期性的pulse
213.  * Input:          
214.  * Return:         
215.  * DateTime:     Mar 4, 2005   8:49:46 AM
216.  * Others:         
217.  */
218. void*  CQnxHardTimer::_PeriodicThread(void *vArguments)
219. {
220. //  printf("CQnxHardTimer::_PeriodicThread/n");
221.     CQnxHardTimer *pHtimer=(CQnxHardTimer *)vArguments;
222.     _THREAD_MESSAGE tmMessage;
223.     int iReceiveIdentifier;
224.     // Infinite loop   
225.     while(1)
226.     {
227.         // Receive the message
228.         iReceiveIdentifier = MsgReceive(pHtimer->m_iTimerChannel, &tmMessage,sizeof(_THREAD_MESSAGE), NULL);
229.                                                 
230.         // Check if this is a pulse message
231.         if(iReceiveIdentifier == 0)
232.         {
233.             // Check if this is the timer pulse
234.             if(tmMessage.pulse.code == PULSE_HARDTIMER)//时间基准
235.             {
236.                 // Perform periodic code here
237.                 pHtimer->RepeatTimerThread();
238. /*              //可以在这里新启动一个线程来处理，例如
239.                 pthread_attr_t attr;                
240.                 //线程初始化
241.                 pthread_attr_init( &attr );
242.                 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED );
243.                 
244.                 //启动秒定时器线程
245.                 pthread_create( NULL, &attr, &_SecondTimerThread, NULL );
247.                 //启动整点定时器线程
248.                 pthread_create( NULL, &attr, &_WholeHourTimerThread, NULL );
249. */
250.             }
251.             if(tmMessage.pulse.code == PULSE_EXIT)
252.             {
253.                 // Break the loop
254. //              printf("Destroying thread/n");
255.                 break;
256.             }
258.         }
259.     }
260.     
261.     // Display the destruction message
262. //  printf("Destroying thread/n");
263.     return 0;
264. }
267. void CQnxHardTimer::RepeatTimerThread()
268. {
269. //  printf("CQnxHardTimer::RepeatTimerThread/n");
270. }

四、使用方法

使用时只需要从上述类里继承一个子类，并在子类里实现RepeatTimerThread就可以了。http://blog.csdn.net/Delores/archive/2008/10/23/3127978.aspx里的CCpuUsed 就是一个例子。