epicsTimerNotify::expireStatus delayVerify::expire ( const epicsTime ¤tTime )
{
this->expireStamp = currentTime;
if ( --expireCount == 0u ) {
expireEvent.signal ();
}
return noRestart;
}
void pvValue(class ProcessVariable &pv, const RawValue::Data *data)
{
{
Guard guard(__FILE__, __LINE__, mutex);
puts("value");
++values;
}
if (! stop_in_connect)
{
puts("Stop in value");
hack.signal();
}
epicsThreadSleep(linger);
}
void SimADC::cycle()
{
epicsTime now = epicsTime::getCurrent();
if(nSamples.value != prev_nSamples) {
X.value.reset();
data.value.reset();
prev_nSamples = nSamples.value;
}
if(!X.value) {
X.value.reset((unsigned int*)malloc(sizeof(epicsUInt32)*prev_nSamples), Freeme<unsigned int>());
unsigned int *val = X.value.get();
for(size_t i=0; i<prev_nSamples; i++)
val[i] = 2*i;
X.shape.resize(1);
X.shape[0] = prev_nSamples;
X.displayLow = val[0];
X.displayHigh = val[prev_nSamples-1];
}
if(!data.value || !data.value.unique())
data.value.reset((double*)malloc(sizeof(double)*prev_nSamples), Freeme<double>());
X.timeStamp = now;
if(!X.value) {
X.severity = 3;
X.message = "Alloc fails";
}
if(!data.value) {
data.severity = 3;
data.message = "Alloc fails";
return;
}
double *val = data.value.get();
for(size_t i=0; i<prev_nSamples; i++)
val[i] = mult.value * sin((freq.value/RAD2DEG)*i + (shift.value/RAD2PCT)) + offset.value;
data.shape.resize(1);
data.shape[0] = prev_nSamples;
updated.signal();
}
TEST_CASE pv_lock_test()
{
LockApp app;
int i, num;
if (getenv("REPEAT"))
num = atoi(getenv("REPEAT"));
else
num = 1;
for (i = 0; i<num; ++i)
{
stop_in_connect = ! (i & 1);
app.start();
hack.wait();
app.stop();
}
TEST_OK;
}
void pvConnected(ProcessVariable &pv, const epicsTime &when)
{
{
Guard guard(__FILE__, __LINE__, mutex);
connected = true;
puts("\nConnected");
}
if (stop_in_connect)
{
puts("Stop in connect");
hack.signal();
}
{
Guard pv_guard(__FILE__, __LINE__, pv);
pv.subscribe(pv_guard);
}
{
Guard ctx_guard(__FILE__, __LINE__, ctx);
ctx.flush(ctx_guard);
}
epicsThreadSleep(linger);
}
//
// verify reasonable timer interval accuracy
//
void testAccuracy ()
{
static const unsigned nTimers = 25u;
delayVerify *pTimers[nTimers];
unsigned i;
unsigned timerCount = 0;
testDiag ( "Testing timer accuracy" );
epicsTimerQueueActive &queue =
epicsTimerQueueActive::allocate ( true, epicsThreadPriorityMax );
for ( i = 0u; i < nTimers; i++ ) {
pTimers[i] = new delayVerify ( i * 0.1 + delayVerifyOffset, queue );
timerCount += pTimers[i] ? 1 : 0;
}
testOk1 ( timerCount == nTimers );
expireCount = nTimers;
for ( i = 0u; i < nTimers; i++ ) {
epicsTime cur = epicsTime::getCurrent ();
pTimers[i]->setBegin ( cur );
pTimers[i]->start ( cur + pTimers[i]->delay () );
}
while ( expireCount != 0u ) {
expireEvent.wait ();
}
double averageMeasuredError = 0.0;
for ( i = 0u; i < nTimers; i++ ) {
averageMeasuredError += pTimers[i]->checkError ();
}
averageMeasuredError /= nTimers;
testDiag ("average timer delay error %f ms",
averageMeasuredError * 1000 );
queue.release ();
}
