is >> t;
if (t>0)
{
- setTickIntervalSec(t/(mNumUpdateScan+1));
+ setTickIntervalSec(t, t/mNumUpdateScan,t,t);
}
else
{
}
}
-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()
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);
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);
#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()
{
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();
}
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();
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;
#include <QThread>
#include <QDateTime>
+#include "DNTimeKeeper.h"
+
class SleeperThread : public QThread
{
public:
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)
{
}
{
}
-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;
}
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