[dennco] re-work the tick interval work flow. The work is still in progress.

diff --git a/Source/layer3/DNEngine.cpp b/Source/layer3/DNEngine.cpp
index b1ef7de..c25f836 100644 (file)
--- a/Source/layer3/DNEngine.cpp
+++ b/Source/layer3/DNEngine.cpp
@@ -155,7 +155,7 @@ bool DNEngine::parseSettingFile(const char *contentRoot)
                     is >> t;
                     if (t>0)
                     {
-                        setTickIntervalSec(t/(mNumUpdateScan+1));
+                        setTickIntervalSec(t, t/mNumUpdateScan,t,t);
                     }
                     else
                     {
@@ -259,10 +259,10 @@ void DNEngine::stopSerialServer()
     }
 }
 
-void DNEngine::setTickIntervalSec(float interval)
+void DNEngine::setTickIntervalSec(float full, float signal, float input, float output)
 {
     if (mTimeKeeper)
-        mTimeKeeper->setIntevalSec(interval);
+        mTimeKeeper->setIntevalSec(full, signal, input, output);
 }
 
 bool DNEngine::startEngine()
@@ -306,32 +306,28 @@ void DNEngine::doTickThread(void *self)
 
     DNEngine *engine = (DNEngine*)self;
     
-    int scanCount = 0;
     while(dnGlobal()->getRunningStatus() == DNGlobal::RUNNIING && engine->isValid())
     {
-        if (scanCount == 0)
+        int state =  engine->mTimeKeeper->sleepUntilNextInterval();
+
+        if (state & DNTimeKeeper::STATE_IN_INPUT_SCAN_TIME)
         {
-            //scan input and all non-interface cells
             engine->mContainer->doTickInputInterfaces(engine->mTimeKeeper->getTickTime());
+        }
+        if (state & DNTimeKeeper::STATE_IN_FULL_SCAN_TIME)
+        {
             engine->mContainer->doTickFullScan(engine->mTimeKeeper->getTickTime());
         }
-        else
+        else if (state & DNTimeKeeper::STATE_IN_SIGNAL_SCAN_TIME)
         {
             //scan non-interface cells which has updated receptor value
             engine->mContainer->doTickSignalScan(engine->mTimeKeeper->getTickTime());
         }
-
-        if (scanCount == engine->mNumUpdateScan)
+        if (state & DNTimeKeeper::STATE_IN_OUTPUT_SCAN_TIME)
         {
             //scan output cells
             engine->mContainer->doTickOutputInterfaces(engine->mTimeKeeper->getTickTime());
         }
-        scanCount++;
-        if (scanCount > engine->mNumUpdateScan)
-        {
-            scanCount = 0;
-        }
-        engine->mTimeKeeper->sleepUntilNextInterval();
     }
 
     dnGlobal()->updateRunningStatus(DNGlobal::STOPPED);

diff --git a/Source/layer3/DNEngine.h b/Source/layer3/DNEngine.h
index 24cbfef..df2ab55 100644 (file)
--- a/Source/layer3/DNEngine.h
+++ b/Source/layer3/DNEngine.h
@@ -45,7 +45,7 @@ public:
     bool        startSerialServer();
     void        stopSerialServer();
 
-    void        setTickIntervalSec(float interval);
+    void        setTickIntervalSec(float full, float signal, float input, float output);
     
     static void doTickThread(void *self);
     float       doClientGetRequest(const char* path);

diff --git a/Source/layer3/DNTimeKeeper.cpp b/Source/layer3/DNTimeKeeper.cpp
index a1d2672..07324fa 100644 (file)
--- a/Source/layer3/DNTimeKeeper.cpp
+++ b/Source/layer3/DNTimeKeeper.cpp
@@ -21,6 +21,10 @@
 
 #include "DNTimeKeeper.h"
 
+const int DNTimeKeeper::STATE_IN_FULL_SCAN_TIME      = 0x01;
+const int DNTimeKeeper::STATE_IN_SIGNAL_SCAN_TIME    = 0x02;
+const int DNTimeKeeper::STATE_IN_INPUT_SCAN_TIME     = 0x04;
+const int DNTimeKeeper::STATE_IN_OUTPUT_SCAN_TIME    = 0x08;
 
 DNTimeKeeper::DNTimeKeeper()
 {
@@ -33,12 +37,12 @@ DNTimeKeeper::~DNTimeKeeper()
         delete impl;
 }
 
-bool DNTimeKeeper::setIntevalSec(float time)
+bool DNTimeKeeper::setIntevalSec(float full, float signal, float input, float output)
 {
-    return impl->setIntevalSec(time);
+    return impl->setIntevalSec(full, signal, input, output);
 }
 
-bool DNTimeKeeper::sleepUntilNextInterval()
+int DNTimeKeeper::sleepUntilNextInterval()
 {
     return impl->sleepUntilNextInterval();
 }

diff --git a/Source/layer3/DNTimeKeeper.h b/Source/layer3/DNTimeKeeper.h
index 647e890..2ade534 100644 (file)
--- a/Source/layer3/DNTimeKeeper.h
+++ b/Source/layer3/DNTimeKeeper.h
@@ -28,8 +28,13 @@ public:
     DNTimeKeeper();
     ~DNTimeKeeper();
     
-    bool                setIntevalSec(float time);
-    bool                sleepUntilNextInterval();
+    static const int    STATE_IN_FULL_SCAN_TIME;
+    static const int    STATE_IN_SIGNAL_SCAN_TIME;
+    static const int    STATE_IN_INPUT_SCAN_TIME;
+    static const int    STATE_IN_OUTPUT_SCAN_TIME;
+
+    bool                setIntevalSec(float full, float signal, float input, float output);
+    int                 sleepUntilNextInterval();
     float               getTickTime();
   
     bool                start();

diff --git a/Source/layer3/DNTimeKeeperImpl.h b/Source/layer3/DNTimeKeeperImpl.h
index 8ea7fc8..ae3cb76 100644 (file)
--- a/Source/layer3/DNTimeKeeperImpl.h
+++ b/Source/layer3/DNTimeKeeperImpl.h
@@ -27,9 +27,9 @@ public:
     
     DNTimeKeeperImpl() {}
     virtual ~DNTimeKeeperImpl() {}
-    
-    virtual bool    setIntevalSec(float time) = 0;
-    virtual bool    sleepUntilNextInterval() = 0;
+
+    virtual bool    setIntevalSec(float full, float signal, float input, float output) = 0;
+    virtual int     sleepUntilNextInterval() = 0;
     virtual float   getTickTime() = 0;
  
     virtual bool    start() = 0;

diff --git a/Source/layer3/platform/qt/qtdntimekeeperimpl.cpp b/Source/layer3/platform/qt/qtdntimekeeperimpl.cpp
index 72a267f..03eea70 100644 (file)
--- a/Source/layer3/platform/qt/qtdntimekeeperimpl.cpp
+++ b/Source/layer3/platform/qt/qtdntimekeeperimpl.cpp
@@ -21,6 +21,8 @@
 #include <QThread>
 #include <QDateTime>
 
+#include "DNTimeKeeper.h"
+
 class SleeperThread : public QThread
 {
 public:
@@ -35,7 +37,10 @@ DNTimeKeeperImpl *DNTimeKeeperImpl::create()
     return new QtDNTimeKeeperImpl;
 }
 
-QtDNTimeKeeperImpl::QtDNTimeKeeperImpl() : mIntervalTime(1000),mAdjustTime(0),mPrevTime(0),mStartTime(0),mTickTime(0)
+QtDNTimeKeeperImpl::QtDNTimeKeeperImpl() :
+    mFullScanIntervalTime(1000),mSignalScanIntervalTime(1000), mInputScanIntervalTime(1000), mOutputScanIntervalTime(1000),
+    mNextFullScanTime(0), mNextSignalScanTime(0), mNextInputScanTime(0), mNextOutputScanTime(0),
+    mStartTime(0),mNextTime(0)
 {
 }
 
@@ -43,52 +48,84 @@ QtDNTimeKeeperImpl::~QtDNTimeKeeperImpl()
 {
 }
 
-bool  QtDNTimeKeeperImpl::setIntevalSec(float time)
+bool  QtDNTimeKeeperImpl::setIntevalSec(float full, float signal, float input, float output)
 {
-    mIntervalTime = time * 1000;
-    mAdjustTime = 0.0;
+    mFullScanIntervalTime = full > 0 ? full * 1000 : 1;
+    mSignalScanIntervalTime = signal > 0 ? signal * 1000 : 1;
+    mInputScanIntervalTime = input > 0 ? input * 1000 : 1;
+    mOutputScanIntervalTime = output > 0 ? output * 1000 : 1;
+
+    start();
+
     return true;
 }
 
-bool  QtDNTimeKeeperImpl::sleepUntilNextInterval()
+int  QtDNTimeKeeperImpl::sleepUntilNextInterval()
 {
-    if (mStartTime == 0)
+    qint64 currentTime = getTickTimeMS();
+    qint64 sleepTime = mNextTime - currentTime;
+    if (sleepTime < 1) sleepTime = 1;
+    SleeperThread::msleep(sleepTime);
+
+    mNextTime = currentTime + 1000;
+    int state = 0;
+
+    if (mNextFullScanTime <= currentTime)
     {
-        start();
+        state |= DNTimeKeeper::STATE_IN_FULL_SCAN_TIME;
+        mNextFullScanTime = currentTime + mFullScanIntervalTime - (currentTime % mFullScanIntervalTime);
     }
-    qint64 currentTime = QDateTime::currentMSecsSinceEpoch();
-    qint64 dt = currentTime - mPrevTime;
-    qint64 wt = mIntervalTime - dt + (int)mAdjustTime;
-    if (wt < 1)  // wait at least 1ms.
+    if (mNextFullScanTime < mNextTime)
+        mNextTime = mNextFullScanTime;
+
+    if (mNextSignalScanTime <= currentTime)
     {
-        wt = 1;
+        state |= DNTimeKeeper::STATE_IN_SIGNAL_SCAN_TIME;
+        mNextSignalScanTime = currentTime + mSignalScanIntervalTime - (currentTime % mSignalScanIntervalTime);
+
     }
-    SleeperThread::msleep(wt);
-    qint64 t = QDateTime::currentMSecsSinceEpoch();
+    if (mNextSignalScanTime < mNextTime)
+        mNextTime = mNextSignalScanTime;
 
-    mAdjustTime += mIntervalTime - (t - mPrevTime);
-    if (mAdjustTime < -mIntervalTime * 0.3)
+    if (mNextInputScanTime <= currentTime)
     {
-        mAdjustTime = -mIntervalTime * 0.3;
+        state |= DNTimeKeeper::STATE_IN_INPUT_SCAN_TIME;
+        mNextInputScanTime = currentTime + mInputScanIntervalTime - (currentTime % mInputScanIntervalTime);
     }
-    mPrevTime = t;
+    if (mNextInputScanTime < mNextTime)
+        mNextTime = mNextInputScanTime;
 
-    mTickTime = (mPrevTime - mStartTime)/1000.0;
+    if (mNextOutputScanTime <= currentTime)
+    {
+        state |= DNTimeKeeper::STATE_IN_OUTPUT_SCAN_TIME;
+        mNextOutputScanTime = currentTime + mOutputScanIntervalTime - (currentTime % mOutputScanIntervalTime);
+    }
+    if (mNextOutputScanTime < mNextTime)
+        mNextTime = mNextOutputScanTime;
 
-    return true;
+    return state;
 }
 
 float QtDNTimeKeeperImpl::getTickTime()
 {
-    return mTickTime;
+    return getTickTimeMS() / 1000.0;
+}
+
+qint64 QtDNTimeKeeperImpl::getTickTimeMS() const
+{
+    return QDateTime::currentMSecsSinceEpoch() - mStartTime;
 }
 
 bool QtDNTimeKeeperImpl::start()
 {
     mStartTime = QDateTime::currentMSecsSinceEpoch();
-    mPrevTime = mStartTime;
-    mAdjustTime = 0.0;
-    mTickTime = 0.0;
+
+    mNextFullScanTime = 0;
+    mNextSignalScanTime = mSignalScanIntervalTime;
+    mNextInputScanTime = 0;
+    mNextOutputScanTime = mOutputScanIntervalTime;
+    mNextTime = 0;
+
     return true;
 }
 

diff --git a/Source/layer3/platform/qt/qtdntimekeeperimpl.h b/Source/layer3/platform/qt/qtdntimekeeperimpl.h
index d5386d3..ba07d1e 100644 (file)
--- a/Source/layer3/platform/qt/qtdntimekeeperimpl.h
+++ b/Source/layer3/platform/qt/qtdntimekeeperimpl.h
@@ -29,19 +29,28 @@ public:
     QtDNTimeKeeperImpl();
     ~QtDNTimeKeeperImpl();
 
-    virtual bool    setIntevalSec(float time);
-    virtual bool    sleepUntilNextInterval();
+    virtual bool    setIntevalSec(float full, float signal, float input, float output);
+    virtual int     sleepUntilNextInterval();
     virtual float   getTickTime();
 
     virtual bool    start();
     virtual bool    stop();
+
 private:
-    qint64          mIntervalTime;
-    float           mAdjustTime;
-    qint64          mPrevTime;
-    qint64          mStartTime;
+    qint64          getTickTimeMS() const;
+
+    qint64          mFullScanIntervalTime;
+    qint64          mSignalScanIntervalTime;
+    qint64          mInputScanIntervalTime;
+    qint64          mOutputScanIntervalTime;
 
-    float           mTickTime;
+    qint64          mNextFullScanTime;
+    qint64          mNextSignalScanTime;
+    qint64          mNextInputScanTime;
+    qint64          mNextOutputScanTime;
+
+    qint64          mStartTime;
+    qint64          mNextTime;
 };
 
 #endif // QTDNTIMEKEEPERIMPL_H