TB10.1 Example Applications: examples/Base/Timers/Periodic/Periodic.cpp Source File

00001 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
-00002 // All rights reserved.
-00003 // This component and the accompanying materials are made available
-00004 // under the terms of "Eclipse Public License v1.0"
-00005 // which accompanies this distribution, and is available
-00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
-00007 //
-00008 // Initial Contributors:
-00009 // Nokia Corporation - initial contribution.
-00010 //
-00011 // Contributors:
-00012 //
-00013 // Description:
-00014 // Shows difference between CPeriodic and CHeartBeat
-00015 // CPeriodic uses repeated RTimer::After() requests to get
-00016 // a periodic tick - simple, but the time the tick is serviced lags
-00017 // increasingly.
-00018 // As a nuance of CPeriodic, it takes a TCallBack to service
-00019 // its requests.
-00020 // CHeartbeat uses repeated RTimer::Lock() requests: its
-00021 // requests complete in synchronization with the beating
-00022 // of the system clock.
-00023 // As a nuance of CHeartbeat, it takes an MBeating* mixin:
-00024 // the MBeating's Beat() function is called when completion
-00025 // occurs in sync, and Synchronize() is called when
-00026 // synchronization has been lost.
-00027 //
-00028 
-00029 
-00030 
-00031 // standard example header
-00032 #include "CommonFramework.h"
-00033 
-00034 // beginning of real example
-00035 
-00036 #include <e32math.h>
-00037 
-00038 void RandomDelay(TInt64& aSeed, TInt /*aTimerNumber*/)
-00039         {
-00040         // initialize seed first time through
-00041         if (aSeed==0)
-00042                 {
-00043                 TTime time;
-00044                 time.HomeTime();
-00045                 aSeed=time.Int64();
-00046                 }
-00047         // ok, here we go
-00048         TReal randomZeroToOne;
-00049         randomZeroToOne = Math::FRand(aSeed);
-00050         TReal realDelay;
-00051         realDelay = randomZeroToOne * randomZeroToOne * 2000000;
-00052         TInt32 intDelay;
-00053         Math::Int(intDelay, realDelay);
-00054         TTimeIntervalMicroSeconds32 delayMicroSeconds;
-00055         delayMicroSeconds=intDelay;
-00056         User::After(delayMicroSeconds);
-00057         }
-00058 
-00059 // A version of the RandomDelay function which is not random ! 
-00060 // The delay is fixed at 1000000us and may be useful to 
-00061 // experiment with. 
-00062 //
-00063 //
-00064 //void RandomDelay(TInt64& /* aSeed */, TInt aTimerNumber)
-00065 //      {
-00066 //      User::After(1000000);
-00067 //  _LIT(KFormatMisc,"Delay for timer %d: 1000000us\n");
-00068 //      console->Printf(KFormatMisc, aTimerNumber);
-00069 //      }
-00070 
-00071 
-00072 class TAppRunner
-00073         {
-00074 public:
-00075         TAppRunner();
-00076         void NotifyFinished(); // notify an active object has finished
-00077         void NotifyStarted(); // notify an active object has started
-00078 // private:
-00079         TInt iActiveObjects; // count of active objects
-00080         };
-00081 
-00082 TAppRunner::TAppRunner()
-00083         {
-00084         iActiveObjects=0;
-00085         }
-00086 
-00087 void TAppRunner::NotifyStarted()
-00088         {
-00089         iActiveObjects++;
-00090         }
-00091 
-00092 void TAppRunner::NotifyFinished()
-00093         {
-00094         iActiveObjects--;
-00095         if (iActiveObjects==0) CActiveScheduler::Stop();
-00096         }
-00097 
-00098 /*
-00099         CPeriodicRunner class
-00100 
-00101         Constructor makes a CPeriodic and sets it off with one-second ticks.
-00102         These are fielded by the callback function, the static Tick(TAny*),
-00103         which simply casts the pointer to a CPeriodicRunner* and calls
-00104         the non-static callback, DoTick().
-00105 
-00106         Processing gets behind: when the ticks left have counted down to zero,
-00107         it should be behind by a second or two.  The destructor indicates how many
-00108         seconds since the object's creation.
-00109 */
-00110 
-00111 class CPeriodicRunner : public CBase
-00112         {
-00113 public:
-00114         // construct, add CPeriodic to active scheduler, and start it
-00115         static CPeriodicRunner* NewL(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner);
-00116         ~CPeriodicRunner(); // destruct and give statistics
-00117 protected:
-00118         CPeriodicRunner(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner);
-00119 private:
-00120         void ConstructL(); // second construction phase
-00121         // functions for TCallBack protocol
-00122         static TInt Tick(TAny* aObject); // directly called
-00123         void DoTick(); // indirectly called
-00124 private:
-00125       // constructor parameters
-00126         TAppRunner& iAppRunner; // notify when started and finished
-00127         TInt iTotalTicks;       // total number of ticks requested
-00128         TInt iTickInterval;     // the tick interval in microseconds
-00129         
-00130           // things set up by ConstructL()
-00131         TTime iStartTime;       // when we were started
-00132         CPeriodic* iPeriodic;   // periodic timer active object
-00133         
-00134           // remaining ticks will be decremented as we go
-00135         TInt iTicksLeft;        // number of ticks before we expire
-00136         TInt iTimerNumber;      // indentifying number for the timer
-00137         
-00138         // seed for random delay generator
-00139         TInt64 iDelaySeed;
-00140         };
-00141 
-00142 // protected C++ constructor
-00143 CPeriodicRunner::CPeriodicRunner(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner)
-00144         : iAppRunner(aAppRunner), iTotalTicks(aTotalTicks), iTickInterval(aTickInterval)
-00145         {}
-00146 
-00147 // private second-phase constructor
-00148 void CPeriodicRunner::ConstructL()
-00149         {
-00150         iStartTime.HomeTime();
-00151         iPeriodic =CPeriodic::NewL(0); // neutral priority
-00152         iAppRunner.NotifyStarted();
-00153         iTimerNumber = iAppRunner.iActiveObjects; // set idenfifying number for timer
-00154         iTicksLeft = iTotalTicks;
-00155         // variable (actually 1 second) delay and interval 
-00156         iPeriodic->Start(iTickInterval,iTickInterval,TCallBack(Tick, this));
-00157         }
-00158 
-00159 // construct, add CPeriodic to active scheduler, and start it
-00160 CPeriodicRunner* CPeriodicRunner::NewL(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner)
-00161         {
-00162         CPeriodicRunner* self=new (ELeave) CPeriodicRunner(aTickInterval, aTotalTicks, aAppRunner);
-00163         CleanupStack::PushL(self);
-00164     self->ConstructL();
-00165         CleanupStack::Pop();
-00166     return self;
-00167         }
-00168 
-00169 // destruct and give statistics
-00170 CPeriodicRunner::~CPeriodicRunner()
-00171         {
-00172         TTimeIntervalMicroSeconds elapsedTime;
-00173         TTime currentTime;
-00174         // set current time
-00175         currentTime.HomeTime(); // set currentTime to now
-00176         // find and show elapsed time & ticks 
-00177         elapsedTime = currentTime.MicroSecondsFrom(iStartTime);
-00178         
-00179         _LIT(KFormat1,"Periodic timer %d finished after: %Ld microseconds for %d %dus ticks\n");
-00180         console->Printf(KFormat1,iTimerNumber,elapsedTime.Int64(),iTotalTicks,iTickInterval);
-00181 
-00182         
-00183         
-00184         //  cancel any outstanding request; delete owned CPeriodic object 
-00185         iPeriodic->Cancel();
-00186     delete iPeriodic;
-00187         // tell app runner we've finished (if we're last, scheduler will stop)
-00188         iAppRunner.NotifyFinished();
-00189         }
-00190 
-00191 // private
-00192 TInt CPeriodicRunner::Tick(TAny* aObject)
-00193         {
-00194         ((CPeriodicRunner*)aObject)->DoTick(); // cast, and call non-static function
-00195         return 1;
-00196         }
-00197 
-00198 // private
-00199 void CPeriodicRunner::DoTick()
-00200         {
-00201         iTicksLeft--;
-00202         _LIT(KFormat2,"Periodic timer %d: %d ticks done\n");
-00203         console->Printf(KFormat2, iTimerNumber, iTotalTicks - iTicksLeft);
-00204         if(iTicksLeft==0)
-00205                 {
-00206                 delete this;
-00207                 }
-00208         RandomDelay(iDelaySeed,iTimerNumber); // a random delay to mess up the timing
-00209         }
-00210 
-00211 /*
-00212         CHeartbeatRunner class
-00213 
-00214         This class receives beats in sync with the system clock.  It also has a much
-00215         nicer interface than for periodic timers - the MBeating mixin, which is nicely
-00216         object-oriented.
-00217 
-00218         Most of the time, the Beat() function is called which trivially updates the tick
-00219         count.  Occasionally, synchronization is lost, and the Synchronize() function
-00220         is called instead: this must find out from the system time how many ticks should
-00221         have been counted, and update things accordingly.
-00222 
-00223         The destructor gives the same comparisons as the CPeriodic's.  The discrepancy
-00224         between the number of ticks and the number of seconds since construction should
-00225         never be more than is accounted for by the last heartbeat.
-00226 */
-00227 
-00228 class CHeartbeatRunner : public CBase, public MBeating
-00229         {
-00230 public:
-00231         // construct, add CHeartbeat to active scheduler, and start it
-00232         static CHeartbeatRunner* NewL(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner);
-00233         ~CHeartbeatRunner(); // destruct and give statistics
-00234 protected:
-00235         CHeartbeatRunner(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner);
-00236 private:
-00237         void ConstructL();
-00238         // functions for MBeating protocol
-00239         void Beat(); // called when beat works ok
-00240         void Synchronize(); // called when we need to synchronize
-00241 private:
-00242         // constructor parameters
-00243         TAppRunner& iAppRunner; // notify when started and finished
-00244         TInt iTotalTicks; // number of ticks requested
-00245         TInt iTickInterval; // tick length in microseconds
-00246         // things set up by ConstructL
-00247         TTime iStartTime; // when we were started
-00248         CHeartbeat* iHeartbeat; // heartbeat active object
-00249         // ticks left decrements as we go
-00250         TInt iTicksLeft; // number of ticks before we expire
-00251         TInt iTimerNumber; // indentifying number for the timer
-00252         // seed for random delay generator
-00253         TInt64 iDelaySeed;
-00254         };
-00255 
-00256 // protected C++ constructor
-00257 CHeartbeatRunner::CHeartbeatRunner(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner)
-00258         :iAppRunner(aAppRunner), iTotalTicks(aTotalTicks), iTickInterval(aTickInterval)
-00259         {}
-00260 
-00261 // private second-phase constructor
-00262 void CHeartbeatRunner::ConstructL()
-00263         {
-00264         iStartTime.HomeTime();
-00265         iHeartbeat=CHeartbeat::NewL(0); // neutral priority
-00266         iAppRunner.NotifyStarted();
-00267         iTimerNumber = iAppRunner.iActiveObjects; // set idenfifying number for timer
-00268         iTicksLeft = iTotalTicks;
-00269         // start the heartbeat timer, beating exactly on the second
-00270         iHeartbeat->Start(ETwelveOClock,this);
-00271         }
-00272 
-00273 // construct, add CHeartbeat to active scheduler, and start it
-00274 CHeartbeatRunner* CHeartbeatRunner::NewL(TInt aTickInterval, TInt aTotalTicks, TAppRunner& aAppRunner)
-00275         {
-00276         CHeartbeatRunner* self=new (ELeave) CHeartbeatRunner(aTickInterval, aTotalTicks, aAppRunner);
-00277         CleanupStack::PushL(self);
-00278     self->ConstructL();
-00279         CleanupStack::Pop();
-00280     return self;
-00281         }
-00282 
-00283 // destruct and give statistics
-00284 CHeartbeatRunner::~CHeartbeatRunner()
-00285         {
-00286         TTimeIntervalMicroSeconds elapsedTime;
-00287         TTime currentTime;
-00288         currentTime.HomeTime(); // set current time to now
-00289         // find and show elapsed time & ticks 
-00290         elapsedTime = currentTime.MicroSecondsFrom(iStartTime); 
-00291         
-00292         _LIT(KFormat3,"Heartbeat timer %d finished after: %Ld microseonds for %d %dus ticks\n");
-00293         console->Printf(KFormat3,iTimerNumber,elapsedTime.Int64(),iTotalTicks,iTickInterval);
-00294         
-00295         //  cancel any outstanding request; delete owned CPeriodic object 
-00296         iHeartbeat->Cancel();
-00297     delete iHeartbeat;
-00298         // tell app runner we've finished (if last, scheduler will stop)
-00299         iAppRunner.NotifyFinished();
-00300         }
-00301 
-00302 // private
-00303 void CHeartbeatRunner::Beat()
-00304         {
-00305         iTicksLeft--;
-00306         if(iTicksLeft<=0)
-00307                 delete this;
-00308         else
-00309                 RandomDelay(iDelaySeed,iTimerNumber); // a random delay to mess up the timing
-00310         }
-00311 
-00312 // private
-00313 void CHeartbeatRunner::Synchronize()
-00314         {
-00315         TInt ticksMissed = 0;
-00316                  // what time in microseconds should be for this tick
-00317         TTime desiredTime = iStartTime + TTimeIntervalMicroSeconds((iTotalTicks - iTicksLeft) * iTickInterval);
-00318         TTime currentTime; // set current time to now
-00319         currentTime.HomeTime();
-00320         TTimeIntervalMicroSeconds missedTime = currentTime.MicroSecondsFrom(desiredTime);
-00321         // Calculate the ticks missed (quickly!)
-00322         TInt64 missedTimeInt = missedTime.Int64(); // convert the missed time interval to an Int64
-00323         
-00324         ticksMissed = (missedTimeInt / iTickInterval);
-00325         //ticksMissed = (missedTimeInt / iTickInterval).GetTInt();
-00326         
-00327         
-00328         // The following loop increments the ticks missed by the same amount, but takes much longer
-00329         // while (desiredTime < currentTime)
-00330         //      {
-00331         //      desiredTime = desiredTime - TTimeIntervalMicroSeconds(iTickInterval);
-00332         //      ticksMissed++;
-00333         //      }
-00334         _LIT(KFormat4,"Ticks done %d\n");
-00335         console->Printf(KFormat4, (iTotalTicks -iTicksLeft));
-00336         
-00337         iTicksLeft = iTicksLeft - ticksMissed;
-00338         TTimeIntervalMicroSeconds elapsedTime;
-00339         elapsedTime = currentTime.MicroSecondsFrom(iStartTime); // find and show elapsed time & ticks 
-00340         _LIT(KFormat5,"Elapsed time: %Ld microseconds\n");
-00341         console->Printf(KFormat5, elapsedTime.Int64());
-00342         
-00343         _LIT(KFormat6,"Synchronize heartbeat timer %d: ticks missed %d: left %d: done now %d\n");
-00344         console->Printf(KFormat6,
-00345                             iTimerNumber,
-00346                                         ticksMissed,
-00347                                         iTicksLeft,
-00348                                         ((iTotalTicks - iTicksLeft) <= iTotalTicks) ? iTotalTicks - iTicksLeft : iTotalTicks
-00349                                    );
-00350         // iTicksLeft can be less than zero
-00351         if(iTicksLeft<=0)
-00352                 {
-00353                 delete this;
-00354                 }
-00355         }
-00356 
-00357 /*
-00358         TAppRunner class
-00359 
-00360         Encapsulates logic for stopping the active scheduler
-00361 */
-00362 
-00363 
-00364 // do the example
-00365 
-00366 void doExampleL()
-00367     {
-00368           // Make and install the active scheduler
-00369         CActiveScheduler*  scheduler = new (ELeave) CActiveScheduler;
-00370         
-00371           // Push onto clean-up stack
-00372         CleanupStack::PushL(scheduler); 
-00373         
-00374           // Install as active scheduler
-00375         CActiveScheduler::Install(scheduler);
-00376 
-00377       // Controls the stopping of the scheduler
-00378         TAppRunner appRunner; 
-00379         
-00380           // Set the tick interval to 1 second.
-00381         TInt TickInterval = 1000000;
-00382 
-00383           // run each kind of timer for increasing numbers of ticks
-00384           // was 10/40/10
-00385                 
-00386         for (TInt total_ticks=4; total_ticks<=6; total_ticks+=2)
-00387                 {               
-00388                   // Create periodic timer
-00389                   //
-00390                   // [nb Comment next line out if you just want to see heart beat runner]
-00391         CPeriodicRunner::NewL(TickInterval, total_ticks, appRunner);
-00392                         
-00393                   // Create hearbeat
-00394                   //
-00395                   // [nb Comment next line out if you just want to see periodic timer]
-00396                 CHeartbeatRunner::NewL(TickInterval, total_ticks, appRunner);
-00397                 }
-00398 
-00399         CActiveScheduler::Start();
-00400         CleanupStack::PopAndDestroy(); // scheduler
-00401         }
-00402 
-