/*returns: (-1,0)=>(failure,success)*/
static long
write_bo_softTrig(boRecord* pbo) {
long ret = 0;
try {
if(!pbo->val)
return 0;
evgSoftSeq* seq = (evgSoftSeq*)pbo->dpvt;
if(!seq)
throw std::runtime_error("Device pvt field not initialized");
SCOPED_LOCK2(seq->m_lock, guard);
evgSeqRam* seqRam = seq->getSeqRam();
if(!seqRam)
throw std::runtime_error("Failed to lookup EVG Seq RAM");
seqRam->softTrig();
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
ret = S_db_noMemory;
}
return ret;
}
/*returns: (-1,0)=>(failure,success)*/
static long
read_wf_eventMask(waveformRecord* pwf) {
long ret = 0;
try {
evgSoftSeq* seq = (evgSoftSeq*)pwf->dpvt;
if(!seq)
throw std::runtime_error("Device pvt field not initialized");
SCOPED_LOCK2(seq->m_lock, guard);
std::vector<epicsUInt8> eventMask = seq->getEventMaskCt();
epicsUInt8* bptr = (epicsUInt8*)pwf->bptr;
for(unsigned int i = 0; i < eventMask.size(); i++)
bptr[i] = eventMask[i];
pwf->nord = (epicsUInt32)eventMask.size();
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_db_noMemory;
}
return ret;
}
/*returns: (-1,0)=>(failure,success)*/
static long
write_bo_pauseSeq(boRecord* pbo) {
long ret = 0;
evgSoftSeq* seq = 0;
try {
if(!pbo->val)
return 0;
seq = (evgSoftSeq*)pbo->dpvt;
if(!seq)
return S_dev_noDevice;
SCOPED_LOCK2(seq->m_lock, guard);
seq->pause();
seq->setErr("");
} catch(std::runtime_error& e) {
seq->setErr(e.what());
errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pbo->name);
ret = S_db_noMemory;
}
return ret;
}
void
bufRxManager::received(CALLBACK* cb)
{
void *vptr;
callbackGetUser(vptr,cb);
bufRxManager &self=*static_cast<bufRxManager*>(vptr);
SCOPED_LOCK2(self.guard, G);
while(true) {
ELLNODE *node=ellGet(&self.usedbufs);
if (!node)
break;
buffer *buf=CONTAINER(node, buffer, node);
G.unlock();
for(ELLNODE *cur=ellFirst(&self.dispatch); cur; cur=ellNext(cur)) {
listener *action=CONTAINER(cur, listener, node);
(action->fn)(action->fnarg, 0, buf->used, buf->data);
}
G.lock();
ellAdd(&self.freebufs, &buf->node);
};
}
/*returns: (-1,0)=>(failure,success)*/
static long
write_wf_timestamp(waveformRecord* pwf) {
epicsStatus ret = 0;
try {
Pvt* pvt = (Pvt*)pwf->dpvt;
if(!pvt)
throw std::runtime_error("Device pvt field not initialized");
evgMrm* evg = (evgMrm*)pvt->evg;
evgSoftSeq* seq = (evgSoftSeq*)pvt->seq;
if(! (evg || seq))
throw std::runtime_error("Device pvt field not initialized correctly");
epicsUInt32 size = pwf->nord;
std::vector<epicsUInt64> ts(size);
SCOPED_LOCK2(seq->m_lock, guard);
if(seq->getTimestampInpMode() == TICKS) {
for(unsigned int i = 0; i < size; i++)
ts[i] = (epicsUInt64)floor(((epicsFloat64*)pwf->bptr)[i] + 0.5);
} else {
/*
* When timestamp Input mode is EGU; Scale the time to seconds
* and then converting seconds to clock ticks
*/
epicsFloat64 seconds;
epicsUInt32 timeScaler = seq->getTimestampResolution() ;
for(unsigned int i = 0; i < size; i++) {
seconds = ((epicsFloat64*)pwf->bptr)[i] / pow(10.0,(int) timeScaler);
ts[i] = (epicsUInt64)floor(seconds *
evg->getEvtClk()->getFrequency() * pow(10.0,6) + 0.5);
}
}
seq->setTimestamp(&ts[0], size);
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_db_noMemory;
}
return ret;
}
/*returns: (0,2)=>(success,success no convert)*/
static long
read_mbbi_trigSrc(mbbiRecord* pmbbi) {
long ret = 0;
try {
evgSoftSeq* seq = (evgSoftSeq*)pmbbi->dpvt;
if(!seq)
return S_dev_noDevice;
SCOPED_LOCK2(seq->m_lock, guard);
pmbbi->rval = seq->getTrigSrcCt();
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pmbbi->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pmbbi->name);
ret = S_db_noMemory;
}
return ret;
}
/*returns: (0,2)=>(success,success no convert)*/
static long
write_mbbo_trigSrc(mbboRecord* pmbbo) {
long ret = 0;
try {
evgSoftSeq* seq = (evgSoftSeq*)pmbbo->dpvt;
if(!seq)
throw std::runtime_error("Device pvt field not initialized");
SCOPED_LOCK2(seq->m_lock, guard);
seq->setTrigSrc((SeqTrigSrc)pmbbo->rval);
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pmbbo->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pmbbo->name);
ret = S_db_noMemory;
}
return ret;
}
/*returns: (-1,0)=>(failure,success)*/
static long
write_wf_eventMask(waveformRecord* pwf) {
long ret = 0;
try {
evgSoftSeq* seq = (evgSoftSeq*)pwf->dpvt;
if(!seq)
throw std::runtime_error("Device pvt field not initialized");
SCOPED_LOCK2(seq->m_lock, guard);
seq->setEventMask((epicsUInt8*)pwf->bptr, pwf->nord);
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_db_noMemory;
}
return ret;
}
/*(0,2)=> success and convert, don't convert)*/
static long
read_bi_commitStatus(biRecord* pbi) {
long ret = 2;
try {
evgSoftSeq* seq = (evgSoftSeq*)pbi->dpvt;
if(!seq)
throw std::runtime_error("Device pvt field not initialized");
SCOPED_LOCK2(seq->m_lock, guard);
pbi->val = seq->isCommited();
pbi->udf = 0;
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pbi->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pbi->name);
ret = S_db_noMemory;
}
return ret;
}
/*(0,2)=>(success, success no convert)*/
static long
read_mbbi_timestampResolution(mbbiRecord* pmbbi) {
long ret = 0;
evgSoftSeq* seq = 0;
try {
seq = (evgSoftSeq*)pmbbi->dpvt;
if(!seq)
throw std::runtime_error("Device pvt field not initialized");
SCOPED_LOCK2(seq->m_lock, guard);
pmbbi->rval = seq->getTimestampResolution();
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pmbbi->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pmbbi->name);
ret = S_db_noMemory;
}
return ret;
}
/*returns: (-1,0)=>(failure,success)*/
static long
read_wf_timestamp(waveformRecord* pwf) {
long ret = 0;
try {
Pvt* dpvt = (Pvt*)pwf->dpvt;
if(!dpvt)
throw std::runtime_error("Initialization failed");
evgMrm* evg = (evgMrm*)dpvt->evg;
evgSoftSeq* seq = (evgSoftSeq*)dpvt->seq;
if(! (evg || seq))
throw std::runtime_error("Device pvt field not initialized correctly");
SCOPED_LOCK2(seq->m_lock, guard);
std::vector<epicsUInt64> timestamp = seq->getTimestampCt();
epicsFloat64 evtClk = evg->getEvtClk()->getFrequency() * pow(10.0,6);
epicsUInt32 timeScaler = seq->getTimestampResolution();
epicsFloat64* bptr = (epicsFloat64*)pwf->bptr;
for(unsigned int i = 0; i < timestamp.size(); i++) {
if(seq->getTimestampInpMode() == TICKS)
bptr[i] = (epicsFloat64)timestamp[i];
else
bptr[i] = timestamp[i] * pow(10.0,(int) timeScaler) / evtClk;
}
pwf->nord = (epicsUInt32)timestamp.size();
} catch(std::runtime_error& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_dev_noDevice;
} catch(std::exception& e) {
errlogPrintf("ERROR: %s : %s\n", e.what(), pwf->name);
ret = S_db_noMemory;
}
return ret;
}
