static long subFinalProc(subRecord *precord)
{
myData *pmyData = (myData*) precord->dpvt;
if(precord->pact) {
if(dbSubFinalDebug) {
epicsPrintf("Proc Phase 2 execution by (thread) %s, (record) %s\n",
epicsThreadGetNameSelf(),
precord->name);
}
precord->val = pmyData->private_counter;
precord->pact = FALSE;
return 0;
}
precord->pact = TRUE;
if(dbSubFinalDebug) {
epicsPrintf("Proc Phase 1 execution by (thread) %s, (record) %s\n",
epicsThreadGetNameSelf(),
precord->name);
}
epicsMessageQueueSend(queueId, (void*) &pmyData, sizeof(myData*));
return 0;
}
int drvM6802_set_DAQstop(drvM6802_taskConfig *ptaskConfig)
{
drvBufferConfig_Node *pbufferNode = NULL;
bufferingThreadQueueData queueData;
drvM6802_controlThreadConfig *pfpdpThreadConfig = (drvM6802_controlThreadConfig*) ptaskConfig->pfpdpThreadConfig;
if ( !ozSetADsFIFOreset( ptaskConfig) ) {
epicsPrintf("\n>>> ozStopADC : ozSetADsFIFOreset...failed! \n");
return ERROR;
}
/* epicsThreadSleep(0.1); */
ozSetTriggerReset(ptaskConfig);
if( stopFpdp() != OK ) printf(" can't stop FPDP \n");
/* epicsThreadSleep(0.1); */
pbufferNode = (drvBufferConfig_Node *)ellFirst(pdrvBufferConfig->pbufferList);
ellDelete(pdrvBufferConfig->pbufferList, &pbufferNode->node);
pbufferNode->nCnt = ptaskConfig->cnt_DMAcallback;
pbufferNode->nStop = 1;
printf("\nFPDP >>> DMA done count= %d\n", ptaskConfig->cnt_DMAcallback);
epicsPrintf("DAQStop after :ellCnt %d \n", ellCount(pdrvBufferConfig->pbufferList) );
queueData.pNode = pbufferNode;
epicsMessageQueueSend(pfpdpThreadConfig->threadQueueId, (void*) &queueData, sizeof(bufferingThreadQueueData));
/* epicsPrintf("\n>>>Last snd ID: %d, DMA cnt: %d\n", (int)pfpdpThreadConfig->threadQueueId, pbufferNode->nCnt); */
return OK;
}
static long devStringoutV792Control_write_stringout(stringoutRecord *precord)
{
ST_dpvt *pST_dpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pST_dpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1; /*(-1,0)=>(failure,success)*/
}
pSTDdev = pST_dpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.n32Arg0 = pST_dpvt->n32Arg0;
/* qData.param.setValue = precord->val; */
strcpy( qData.param.setStr, precord->val );
/* db processing: phase I */
if(precord->pact == FALSE)
{
precord->pact = TRUE;
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pST_dpvt->ind)
{
case STRINGOUT_TAG:
qData.pFunc = devV792_STRINGOUT_TAG;
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*(-1,0)=>(failure,success)*/
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE)
{
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf() );
#endif
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(-1,0)=>(failure,success)*/
}
return -1; /*(-1,0)=>(failure,success)*/
}
static long devStringoutAdmin_write_stringout(stringoutRecord *precord)
{
ST_devAdmin_dpvt *pdevAdmin_dpvt = (ST_devAdmin_dpvt*) precord->dpvt;
ST_ADMIN *pAdminCfg;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pdevAdmin_dpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1; /*(-1,0)=>(failure,success)*/
}
pAdminCfg = pdevAdmin_dpvt->ptaskConfig;
pControlThreadConfig = pAdminCfg->pST_adminCtrlThread;
qData.param.precord = (struct dbCommon *)precord;
strcpy( qData.param.setStr, precord->val );
if(precord->pact == FALSE)
{
precord->pact = TRUE;
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pdevAdmin_dpvt->ind)
{
case 0:
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId, (void*) &qData, sizeof(ST_threadQueueData));
return 0; /*(-1,0)=>(failure,success)*/
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE)
{
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s) %d\n", precord->name, epicsThreadGetNameSelf() );
#endif
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(-1,0)=>(failure,success)*/
}
return -1; /*(-1,0)=>(failure,success)*/
}
static long doCalc(acalcoutRecord *pcalc) {
calcMessage msg;
int doAsync = 0;
if (aCalcoutRecordDebug >= 10)
printf("acalcoutRecord(%s):doCalc\n", pcalc->name);
if ( acalcGetNumElements(pcalc) > aCalcAsyncThreshold )
doAsync = 1;
/* if required infrastructure doesn't yet exist, create it */
if (doAsync && acalcMsgQueue == NULL) {
acalcMsgQueue = epicsMessageQueueCreate(MAX_MSG, MSG_SIZE);
if (acalcMsgQueue==NULL) {
printf("aCalcoutRecord: Unable to create message queue\n");
return(-1);
}
acalcThreadId = epicsThreadCreate("acalcPerformTask", PRIORITY,
epicsThreadGetStackSize(epicsThreadStackBig),
(EPICSTHREADFUNC)acalcPerformTask, (void *)epicsThreadGetIdSelf());
if (acalcThreadId == NULL) {
printf("aCalcoutRecord: Unable to create acalcPerformTask\n");
epicsMessageQueueDestroy(acalcMsgQueue);
acalcMsgQueue = NULL;
return(-1);
}
}
/* Ideally, we should do short calculations in this thread, and queue long calculations.
* But aCalcPerform is not reentrant (global value stack), so for now we queue everything.
*/
if (doAsync) {
if (aCalcoutRecordDebug >= 2) printf("acalcoutRecord(%s):doCalc async\n", pcalc->name);
pcalc->cact = 1; /* Tell caller that we went asynchronous */
msg.pcalc = pcalc;
epicsMessageQueueSend(acalcMsgQueue, (void *)&msg, MSG_SIZE);
return(0);
} else {
if (aCalcoutRecordDebug >= 2) printf("acalcoutRecord(%s):doCalc sync\n", pcalc->name);
call_aCalcPerform(pcalc);
}
return(0);
}
static long reinitConversion(struct cvtRecord *pcvt)
{
long qstatus;
struct reinitMsg msg;
msg.record = pcvt;
msg.meth = pcvt->nmet;
if (pcvt->nmet != menuCvtMethodLinear) {
strncpy(msg.spec, pcvt->nspe, SPEC_SIZE);
strncpy(msg.bdir, pcvt->nbdi, BDIR_SIZE);
strncpy(msg.tdir, pcvt->ntdi, TDIR_SIZE);
}
qstatus = epicsMessageQueueSend(
initConversionQ, (void*)&msg, REINIT_MSG_SIZE);
if (qstatus == -1) {
errmsg("internal error: msgQ overrun");
return -1;
}
return 0;
}
int32 CVICALLBACK DoneCallback(TaskHandle taskHandle, int32 status, void *callbackData)
{
int32 error=0;
char errBuff[2048]={'\0'};
DaqQueueData queueData;
printf("Read Done!!!\n");
DAQmxErrChk (status);
DAQmxErrChk(DAQmxStopTask(daq6220pvt.taskHandle));
daq6220pvt.status = DAQ_STATUS_STOP;
queueData.opcode = OP_CODE_DAQ_MDSPLUS;
epicsMessageQueueSend(daq6220pvt.DaqQueueId, (void *)&queueData, sizeof(DaqQueueData));
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
DAQmxClearTask(daq6220pvt.taskHandle);
printf("DAQmx Error(6220): %s\n",errBuff);
}
return -1;
}
static long devAoNI6123_write_ao(aoRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if (!pSTdpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return 0;
}
pSTDdev = pSTdpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.pFunc = NULL;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = precord->val;
qData.param.n32Arg0 = pSTdpvt->n32Arg0;
/* db processing: phase I */
if(precord->pact == FALSE) {
precord->pact = TRUE;
kLog (K_DEBUG, "[devAoNI6123_write_ao] db processing: phase I %s (%s)\n", precord->name,
epicsThreadGetNameSelf());
switch(pSTdpvt->ind) {
case AO_DAQ_MIN_VOLT:
qData.pFunc = devNI6123_AO_DAQ_MIN_VOLT;
break;
case AO_DAQ_MAX_VOLT:
qData.pFunc = devNI6123_AO_DAQ_MAX_VOLT;
break;
case AO_DAQ_SAMPLING_RATE:
qData.pFunc = devNI6123_AO_DAQ_SAMPLEING_RATE;
break;
case AO_DAQ_SAMPLING_TIME:
qData.pFunc = devNI6123_AO_DAQ_SAMPLEING_TIME;
break;
case AO_DAQ_BEAM_PLUSE_T0:
qData.pFunc = devNI6123_AO_BEAM_PLUSE_T0;
break;
case AO_DAQ_BEAM_PLUSE_T1:
qData.pFunc = devNI6123_AO_BEAM_PLUSE_T1;
break;
case AO_DAQ_BEAM_PLUSE:
qData.pFunc = devNI6123_AO_BEAM_PLUSE;
break;
case AO_INTEGRAL_TIME :
qData.pFunc = devNI6123_AO_INTEGRAL_TIME;
break;
case AO_FLOW :
qData.pFunc = devNI6123_AO_FLOW;
break;
case AO_DENSITY_FRINGE :
qData.pFunc = devNI6123_AO_FRINGE;
break;
case AO_DENSITY_LIMITE_UP :
qData.pFunc = devNI6123_AO_LIMITE_UP;
break;
case AO_DENSITY_LIMITE_LOW :
qData.pFunc = devNI6123_AO_LIMITE_LOW;
break;
case AO_DENSITY_CONSTANT_A :
qData.pFunc = devNI6123_AO_CONSTANT_A;
break;
case AO_DENSITY_CONSTANT_B :
qData.pFunc = devNI6123_AO_CONSTANT_B;
break;
case AO_DENSITY_CONSTANT_C :
qData.pFunc = devNI6123_AO_CONSTANT_C;
break;
case AO_DENSITY_CONSTANT_D :
qData.pFunc = devNI6123_AO_CONSTANT_D;
break;
case AO_MDS_PARAM_VALUE1 :
qData.pFunc = devNI6123_AO_MDS_PARAM_VALUE1;
break;
case AO_MDS_PARAM_VALUE2 :
qData.pFunc = devNI6123_AO_MDS_PARAM_VALUE2;
break;
case AO_MDS_PARAM_VALUE3 :
qData.pFunc = devNI6123_AO_MDS_PARAM_VALUE3;
break;
case AO_MDS_PARAM_VALUE4 :
qData.pFunc = devNI6123_AO_MDS_PARAM_VALUE4;
break;
case AO_MDS_PARAM_VALUE5 :
qData.pFunc = devNI6123_AO_MDS_PARAM_VALUE5;
break;
}
if (NULL != qData.pFunc) {
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
}
return 0;
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE) {
kLog (K_DEBUG, "[devAoNI6123_write_ao] db processing: phase II %s (%s)\n",
precord->name, epicsThreadGetNameSelf());
precord->pact = FALSE;
precord->udf = FALSE;
return 2; /* don't convert */
}
return 0;
}
static long devAoNI6250_write_ao(aoRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if (!pSTdpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return 0;
}
pSTDdev = pSTdpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.pFunc = NULL;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = precord->val;
qData.param.n32Arg0 = pSTdpvt->n32Arg0;
/* db processing: phase I */
if(precord->pact == FALSE) {
precord->pact = TRUE;
kLog (K_DEBUG, "[devAoNI6250_write_ao] db processing: phase I %s (%s)\n", precord->name,
epicsThreadGetNameSelf());
switch(pSTdpvt->ind) {
case AO_DAQ_MIN_VOLT:
qData.pFunc = devNI6250_AO_DAQ_MIN_VOLT;
break;
case AO_DAQ_MAX_VOLT:
qData.pFunc = devNI6250_AO_DAQ_MAX_VOLT;
break;
case AO_DAQ_GAIN:
qData.pFunc = devNI6250_AO_DAQ_GAIN;
break;
case AO_DAQ_OFFSET:
qData.pFunc = devNI6250_AO_DAQ_OFFSET;
break;
case AO_DAQ_CUTOFF_FREQ:
qData.pFunc = devNI6250_AO_DAQ_CUTOFF_FREQ;
break;
}
if (NULL != qData.pFunc) {
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
}
return 0;
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE) {
kLog (K_DEBUG, "[devAoNI6250_write_ao] db processing: phase II %s (%s)\n",
precord->name, epicsThreadGetNameSelf());
precord->pact = FALSE;
precord->udf = FALSE;
return 2; /* don't convert */
}
return 0;
}
int acq196_htstream(ST_STD_device *pSTDdev)
{
int next = BUFFERA;
int timeouts = 0;
/*#define FD (ST_ACQ196*)(pSTDdev->pUser)->drv_bufAB[BUFFERA].fd */
int started = 0;
int rc=0;
unsigned long int syscalls = 0;
ST_ACQ196 *pAcq196;
pAcq196 = (ST_ACQ196 *)pSTDdev->pUser;
#define FD pAcq196->drv_bufAB[BUFFERA].fd
ST_User_Buff_node queueData;
ST_buf_node *pbufferNode = NULL;
// ST_threadCfg *pDAQST_threadConfig=NULL;
// pDAQST_threadConfig = (ST_threadCfg*) pSTDdev.ST_BuffThread;
// if( !pDAQST_threadConfig ) {
// printf("ERROR! %s can't recive Buff Thread\n", pSTDdev->taskName );
// return WR_ERROR;
// }
if( acq196_initMapping(pAcq196->drv_bufAB+0, (int)pAcq196->slot) == WR_ERROR )
printf("ERROR! acq196_initMapping() buf 0\n");
if( acq196_initMapping(pAcq196->drv_bufAB+1, (int)pAcq196->slot) == WR_ERROR )
printf("ERROR! acq196_initMapping() buf 1\n");
#if PRINT_DAQ_DEBUG
epicsPrintf("\n %s: pSTDdev: %p, pAcq196: %p , pST_BuffThread: %p\n",pSTDdev->taskName, pSTDdev, pAcq196, pSTDdev->ST_RingBufThread );
#endif
if( acq196_setDIO_rising(pSTDdev) == WR_ERROR ) {
printf("\n>>> drvACQ196_RUN_start: acq196_setDIO_rising()... ERROR" );
acq196_closeMapping(pAcq196->drv_bufAB+0);
acq196_closeMapping(pAcq196->drv_bufAB+1);
return WR_ERROR;
}
while( pSTDdev->StatusDev & DEV_IN_LOOP_HTSTREAM )
{
#if DEBUG_PRINT_HTSTREAM
printf("\n>>> acq196_htstream: call ioctl(xxx)...stopmsg:%d, %p. ", pAcq196->gotDAQstopMsg, pAcq196);
rc = ioctl(FD, ACQ200_BUFFER_AB_IOWR, &(pAcq196->drv_ops) );
printf("return(%d)... msg:%d, %p \n", rc, pAcq196->gotDAQstopMsg, pAcq196);
#else
rc = ioctl(FD, ACQ200_BUFFER_AB_IOWR, &(pAcq196->drv_ops) );
#endif
if (rc >= 0)
{
if (acq200_debug && timeouts != 0){
printf("acq200_debug && timeouts != 0\n");
}
timeouts = 0;
started = 1;
} else if (rc == -ETIMEDOUT){
if (acq200_debug){
fputc('.', stderr); fflush(stderr);
}
if (started && ++timeouts >= MAXTO){
perror("TIMEOUT?");
acq196_closeMapping(pAcq196->drv_bufAB+0);
acq196_closeMapping(pAcq196->drv_bufAB+1);
#if USE_FILE_POINTER
fclose(pAcq196->fpRaw);
#else
close(pAcq196->R_file);
#endif
return rc;
}else{
continue;
}
} else {
perror("ERROR ioctl(ACQ200_BUFFER_AB_IOWR)");
acq196_closeMapping(pAcq196->drv_bufAB+0);
acq196_closeMapping(pAcq196->drv_bufAB+1);
#if USE_FILE_POINTER
fclose(pAcq196->fpRaw);
#else
close(pAcq196->R_file);
#endif
return rc;
}
pAcq196->drv_ops.ci.recycle = 0;
/* queueData.u32Cnt = syscalls; */
if (pAcq196->drv_ops.ds.full&BUFFER_FLAG_LUT[next])
{
pAcq196->rawDataSize += pAcq196->drv_ops.ds.len[next];
#if DEBUG_PRINT_HTSTREAM
printf("1N:%d %8d %8d :", next, pAcq196->drv_ops.ds.sid[next], pAcq196->drv_ops.ds.len[next]);
#endif
pAcq196->drv_ops.ci.recycle |= BUFFER_FLAG_LUT[next];
pbufferNode = (ST_buf_node *)ellFirst(pSTDdev->pList_BufferNode);
ellDelete(pSTDdev->pList_BufferNode, &pbufferNode->node);
memcpy( pbufferNode->data, pAcq196->drv_bufAB[next].pbuf, pAcq196->drv_ops.ds.len[next]);
queueData.pNode = pbufferNode;
queueData.size = pAcq196->drv_ops.ds.len[next];
queueData.opcode = QUEUE_OPCODE_NORMAL;
epicsMessageQueueSend(pSTDdev->ST_RingBufThread.threadQueueId, (void*) &queueData, sizeof(ST_User_Buff_node));
if( pAcq196->gotDAQstopMsg )
{
if( pAcq196->rawDataSize >= pAcq196->needDataSize )
{
queueData.pNode = NULL;
queueData.opcode = QUEUE_OPCODE_CLOSE_FILE;
/* if there is some data in next buffer, then do not send EOB message */
if( !(pAcq196->drv_ops.ds.full&BUFFER_FLAG_LUT[!next]) )
{
pSTDdev->StatusDev &= ~DEV_IN_LOOP_HTSTREAM;
#if PRINT_DMA_NUM
printf("\n>>> [2.1]%s: send EOB message.\n", pSTDdev->taskName);
#endif
epicsMessageQueueSend(pSTDdev->ST_RingBufThread.threadQueueId, (void*) &queueData, sizeof(ST_User_Buff_node));
pAcq196->gotDAQstopMsg = 0;
} else {
printf("\n>>> %s: got Stop Msg in FirstBuffer. will be passed to next buffer.\n", pSTDdev->taskName);
}
}
#if 0
else{
printf(">>> %s required:%d, acq: %d\n", pSTDdev->taskName, pAcq196->needDataSize, pAcq196->rawDataSize );
}
#endif
}
/* write(pSTDdev->R_file, pSTDdev->drv_bufAB[next].pbuf, pSTDdev->drv_ops.ds.len[next]); */
/* printf("index %d len %d\n", next, pSTDdev->drv_ops.ds.len[next]); */
next = !next;
if (pAcq196->drv_ops.ds.full&BUFFER_FLAG_LUT[next])
{
pAcq196->rawDataSize += pAcq196->drv_ops.ds.len[next];
#if DEBUG_PRINT_HTSTREAM
printf("2N:%d %8d %8d :", next, pAcq196->drv_ops.ds.sid[next], pAcq196->drv_ops.ds.len[next]);
#endif
pAcq196->drv_ops.ci.recycle |= BUFFER_FLAG_LUT[next];
pbufferNode = (ST_buf_node *)ellFirst(pSTDdev->pList_BufferNode);
ellDelete(pSTDdev->pList_BufferNode, &pbufferNode->node);
memcpy( pbufferNode->data, pAcq196->drv_bufAB[next].pbuf, pAcq196->drv_ops.ds.len[next]);
queueData.pNode = pbufferNode;
queueData.size = pAcq196->drv_ops.ds.len[next];
queueData.opcode = QUEUE_OPCODE_NORMAL;
epicsMessageQueueSend(pSTDdev->ST_RingBufThread.threadQueueId, (void*) &queueData, sizeof(ST_User_Buff_node));
if( pAcq196->gotDAQstopMsg )
{
if( pAcq196->rawDataSize >= pAcq196->needDataSize )
{
pSTDdev->StatusDev &= ~DEV_IN_LOOP_HTSTREAM;
queueData.pNode = NULL;
queueData.opcode = QUEUE_OPCODE_CLOSE_FILE;
#if PRINT_DMA_NUM
printf("\n>>> [2.2]%s: send EOB message.\n", pSTDdev->taskName);
#endif
epicsMessageQueueSend(pSTDdev->ST_RingBufThread.threadQueueId, (void*) &queueData, sizeof(ST_User_Buff_node));
pAcq196->gotDAQstopMsg = 0;
}
#if 0
else{
printf(">>> %s required:%d, acq: %d\n", pSTDdev->taskName, pAcq196->needDataSize, pAcq196->rawDataSize );
}
#endif
}
/* write(pSTDdev->R_file, pSTDdev->drv_bufAB[next].pbuf, pSTDdev->drv_ops.ds.len[next]); */
/* printf("index %d len %d\n", next, pSTDdev->drv_ops.ds.len[next]); */
next = !next;
} /* second buffer task... */
} /* first buffer task... */
if (pAcq196->drv_ops.ds.full&FULL_EOF){
break;
} /* if (pSTDdev->drv_ops.ds.full&FULL_EOF){ */
syscalls++;
} /* while( pSTDdev->StatusDev & DEV_IN_LOOP_HTSTREAM ) */
/* move to ring buffer for waiting time consume process..
acq196_closeMapping(pSTDdev->drv_bufAB+0);
acq196_closeMapping(pSTDdev->drv_bufAB+1);
*/
printf(">>> %s: Total/Need:: %.2f/%.2f MB Cnt:%lu\n", pSTDdev->taskName,
(float)pAcq196->rawDataSize/1024.0/1024.0,
pAcq196->needDataSize/1024.0/1024.0, syscalls);
return WR_OK;
}
int main(int argc, char**argv)
{
struct sockaddr_in si_me;
struct sockaddr_in moderator_udp_sockaddr;
unsigned short packet_tag;
unsigned int i,j,temp_NPACK;
SOCKET s, moderator_udp_sock_fd;
int this_frame_has_aligment_errors=0;
char temp_char;
unsigned int packet_id, local_packet_id;
long packet_id_gap;
int received_data_subsets=0;
moderation_type moderation=NOUDPMOD;
clock_t timer_a=0,timer_b;
double time_interval;
char moderator_string[MAX_STRLEN];
id_mode packet_id_mode;
ptr_list = epicsMessageQueueCreate(MAX_PENDING_BUFFERS, sizeof(unsigned char *));
if (ptr_list == 0) {
printf("epicsMessageQueueCreate failed\n");
return -1;
}
if (osiSockAttach() == 0) {
printf("osiSockAttach failed\n");
return -1;
}
if(argc==4){
if (strcmp(argv[3],"UDPMOD")==0)
moderation=UDPMOD;
else
moderation=NOUDPMOD;
verbose=atoi(argv[2]);
if (strcmp(argv[1],"FRAG_ID")==0)
packet_id_mode=FRAG_ID;
else
packet_id_mode=NOFRAG_ID;
}
if(argc==3){
verbose=atoi(argv[2]);
if (strcmp(argv[1],"FRAG_ID")==0)
packet_id_mode=FRAG_ID;
else
packet_id_mode=NOFRAG_ID;
}
else if(argc==2){
verbose=0;
if (strcmp(argv[1],"FRAG_ID")==0)
packet_id_mode=FRAG_ID;
else
packet_id_mode=NOFRAG_ID;
}
else{
verbose=0;
packet_id_mode=FRAG_ID;
moderation=NOUDPMOD;
}
buf=(unsigned char*)databuffer_allocation(MAX_PACK_LEN*DEFAULT_NPACK);
if ((s=epicsSocketCreate(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
{
printf("\r\nError creating socket error =%s", strerror(errno));
scanf("%c%*c",&temp_char);
return 1;
}
memset((char *) &si_me, 0, sizeof(si_me));
si_me.sin_family = AF_INET;
si_me.sin_port = htons(PORTA);
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(s, (struct sockaddr *) &si_me, sizeof(si_me))==-1)
{
printf("\r\nError in binding data receiver socket");
//wait_akey();
return 1;
}
if ((moderator_udp_sock_fd=epicsSocketCreate(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
{
printf("\r\nError creating moderator socket error =%s", strerror(errno));
scanf("%c%*c",&temp_char);
return 1;
}
memset((char *) &moderator_udp_sockaddr, 0, sizeof(moderator_udp_sockaddr));
moderator_udp_sockaddr.sin_family = AF_INET;
moderator_udp_sockaddr.sin_port = htons(MOD_UDP_REMOTE_PORT);
// The following is not support on Linux. Is it needed?
if (hostToIPAddr("192.168.0.255", &moderator_udp_sockaddr.sin_addr) < 0)
printf("PROC:hostToIPAddr failed\n");
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b1=192; //l'indirizzo IP!!!
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b2=168;
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b3=0;
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b4=255;
int buffsize;
osiSocklen_t czm = sizeof( int);
int received_bytes;
buffsize = MAXBUF;
if (setsockopt(s, SOL_SOCKET,
SO_RCVBUF,
(char*)&buffsize,
czm) != -1)
{
if(verbose>=2)printf("\r\nTrying to set Receive Buffer = %d", buffsize);
}
if (getsockopt(s, SOL_SOCKET,
SO_RCVBUF,
(char*)&buffsize,
&czm) != -1)
{
if(verbose>=2)printf("\r\nReceive buffer is now = %d ", buffsize);
if (buffsize == MAXBUF)
{
if(verbose>=2)printf("OK");
}
else
{
if(verbose>=2)printf("ERROR Buffer Size too big!");
}
}
epicsThreadCreate("key_proc",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)key_proc, (void*)&i);
epicsThreadCreate("module_data_parser_thread",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)module_data_parser_thread, NULL);
while(looping){
// sem_wait(&(ptr_list.put_sem));
this_frame_has_aligment_errors=0;
temp_NPACK=DEFAULT_NPACK;
i=0;
if(packet_id_mode==FRAG_ID){
while(i<temp_NPACK ){
j=0;
while(j<DAQ_PACK_FRAGM){
received_bytes=recvfrom(s,(char*) buf+(i*MAX_PACK_LEN), MAX_PACK_LEN,0, NULL, 0);
if (received_bytes== -1)
printf("\rError receiveing datagram");
else if(received_bytes==MAX_PACK_LEN){
if(i==0) timer_a=clock();
received_packets++;
packet_tag=*buf;
if(packet_tag & AUTOCAL_DATA)
temp_NPACK=AUTOCAL_NPACK;
else
temp_NPACK=DEFAULT_NPACK;
/********************************************************************/;
packet_id=buf[MAX_PACK_LEN*(i)+PACKET_ID_OFFSET]<<8;
packet_id+=buf[MAX_PACK_LEN*(i)+1+PACKET_ID_OFFSET];
packet_id=packet_id%DAQ_PACK_FRAGM;
packet_id_gap=(packet_id-j);
if(packet_id_gap!=0){
if(id_error_packets<10)
printf("ID: %d j= %d\n",packet_id,j);
id_error_packets++;
this_frame_has_aligment_errors=1;
}
if(packet_id_gap>=0){
j+=(packet_id_gap+1);
i+=(packet_id_gap+1);
}
else{
j=DAQ_PACK_FRAGM;
i+=DAQ_PACK_FRAGM;
}
}
}
if(moderation==UDPMOD){
sprintf(moderator_string,"DATASUBSET_RECEIVED %d %d\n",received_data_subsets,temp_NPACK/DAQ_PACK_FRAGM);
received_data_subsets++;
if (sendto(moderator_udp_sock_fd,
moderator_string,
strlen(moderator_string),
0,
(struct sockaddr*)&moderator_udp_sockaddr,
(osiSocklen_t)sizeof(moderator_udp_sockaddr))==-1)
printf("\r\n!!Error sending moderating datagram!!");
}
}
} else{
while(i<temp_NPACK ){
received_bytes=recvfrom(s,(char*) buf+(i*MAX_PACK_LEN), MAX_PACK_LEN,0, NULL, 0);
if (received_bytes== -1)
printf("\rError receiveing datagram");
else if(received_bytes==MAX_PACK_LEN){
if(i==0) timer_a=clock();
//i++;j++;
received_packets++;
packet_tag=*buf;
if(packet_tag & AUTOCAL_DATA)
temp_NPACK=AUTOCAL_NPACK;
else
temp_NPACK=DEFAULT_NPACK;
packet_id=buf[MAX_PACK_LEN*(i)+PACKET_ID_OFFSET]<<8;
packet_id+=buf[MAX_PACK_LEN*(i)+1+PACKET_ID_OFFSET];
packet_id_gap=(packet_id-i);//
if(packet_id_gap!=0){
id_error_packets++;
this_frame_has_aligment_errors=1;
}
if(packet_id_gap>=0){
i+=(packet_id_gap+1);
}
else{
i=temp_NPACK;
}
if((i%DAQ_PACK_FRAGM)==0 && i!=0 && moderation==UDPMOD){
sprintf(moderator_string,"DATASUBSET_RECEIVED %d %d\n",received_data_subsets,temp_NPACK/DAQ_PACK_FRAGM);
received_data_subsets++;
if (sendto(moderator_udp_sock_fd,
moderator_string,
strlen(moderator_string),
0,
(struct sockaddr*)&moderator_udp_sockaddr,
sizeof(moderator_udp_sockaddr))==-1)
printf("\r\n!!Error sending moderating datagram!!");
}
}
}
}
received_data_subsets=0;
if(verbose>=1){
timer_b=clock();
time_interval=(double)(timer_b-timer_a)/CLOCKS_PER_SEC;
printf("MAIN:%d packets(%d bytes each) have been received in %.3f s ",i,MAX_PACK_LEN,time_interval);
printf("(%.3f Mbps)\n",(i*MAX_PACK_LEN*8)/(time_interval*1024*1024));
}
i=0;
local_packet_id=0;
process_buf=(unsigned char*)databuffer_allocation((MAX_PACK_LEN-PACKET_EXTRA_BYTES+PACKET_TAG_BYTES)*DEFAULT_NPACK);
if((buf==NULL)||(process_buf==NULL)){
printf("error allocating buffers\n");
exit(0);
}
else
if(verbose>=1)
printf("MAIN:New Processing Buffer Allocated\n");
while((i<temp_NPACK))
{
memcpy(process_buf+PACKET_TAG_BYTES+(PACKET_SENSOR_DATA_BYTES*local_packet_id),
buf+PACKET_SENSOR_DATA_OFFSET+(MAX_PACK_LEN*i), PACKET_SENSOR_DATA_BYTES);
for(j=0;j<PACKET_TAG_BYTES;j++)
process_buf[PACKET_TAG_OFFSET+j]=buf[j];//copio il PACKET_TAG del buffer per processing
if(this_frame_has_aligment_errors)
process_buf[PACKET_TAG_OFFSET]|=FRAME_HAS_ALIGN_ERRORS;
else
process_buf[PACKET_TAG_OFFSET]&=(~FRAME_HAS_ALIGN_ERRORS);
local_packet_id++;
i++;
}
printf("Main: sending process_buf=%p\n", process_buf);
epicsMessageQueueSend(ptr_list, &process_buf, sizeof(&process_buf));
}
free(buf);
free(process_buf);
scanf("%c%*c",&temp_char);
return EXIT_SUCCESS;
}
static long devAoAdmin_write_ao(aoRecord *precord)
{
ST_devAdmin_dpvt *pdevAdmin_dpvt = (ST_devAdmin_dpvt*) precord->dpvt;
ST_ADMIN *pAdminCfg;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pdevAdmin_dpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1;
}
pAdminCfg = pdevAdmin_dpvt->ptaskConfig;
pControlThreadConfig = pAdminCfg->pST_adminCtrlThread;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = precord->val;
/* db processing: phase I */
if(precord->pact == FALSE)
{
precord->pact = TRUE;
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pdevAdmin_dpvt->ind)
{
case AO_SHOT_NUMBER:
qData.pFunc = devAdmin_AO_SHOT_NUMBER;
break;
case AO_OP_MODE:
qData.pFunc = devAdmin_AO_OP_MODE;
break;
case AO_SET_BLIP:
qData.pFunc = devAdmin_AO_SET_BLIP;
break;
case AO_CREATE_LOCAL_SHOT:
qData.pFunc = devAdmin_AO_CREATE_LOCAL_SHOT;
break;
case AO_SAMPLING_RATE:
qData.pFunc = devAdmin_AO_CLOCK;
break;
case AO_START_T0:
qData.pFunc = devAdmin_AO_T0;
qData.param.n32Arg0 = strtoul(pdevAdmin_dpvt->arg1, NULL, 0);
break;
case AO_STOP_T1:
qData.pFunc = devAdmin_AO_T1;
qData.param.n32Arg0 = strtoul(pdevAdmin_dpvt->arg1, NULL, 0);
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*(0)=>(success ) */
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE)
{
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
precord->pact = FALSE;
precord->udf = FALSE;
switch(pdevAdmin_dpvt->ind)
{
case AO_OP_MODE: precord->val = pAdminCfg->ST_Base.opMode; break;
default: break;
}
return 0; /*(0)=>(success ) */
}
return -1;
}
static long devAoRfm5565_write_ao(aoRecord *precord)
{
ST_dpvt *pDpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_RFM5565* pRFM5565;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
RFM2G_STATUS result;
RFM2G_UINT32 buffer;
if(!pDpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1;
}
pSTDdev = pDpvt->pSTDdev;
pRFM5565 = (ST_RFM5565 *)pSTDdev->pUser;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = precord->val;
/* db processing: phase I */
if(precord->pact == FALSE)
{
precord->pact = TRUE;
#if 0
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pDpvt->ind)
{
case AO_SET_READ_OFFSET:
pRFM5565->Offset = (RFM2G_UINT32)precord->val;
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(0)=>(success ) */
case AO_RFM_WRITE_VALUE:
buffer = (RFM2G_UINT32)precord->val;
result = RFM2gWrite( pRFM5565->Handle, pRFM5565->Offset, &buffer, sizeof(RFM2G_UINT32)*1 );
if( result != RFM2G_SUCCESS )
{
printf( "ERROR: Could not write data to Reflective Memory.\n" );
RFM2gClose( &pRFM5565->Handle );
return(-1);
}
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(0)=>(success ) */
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*(0)=>(success ) */
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE)
{
#if 0
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pDpvt->ind)
{
// case AO_SET_READ_OFFSET: precord->val = pRFM5565->Offset ; break;
default: break;
}
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(0)=>(success ) */
}
return -1;
}
static long devAoV792Control_write_ao(aoRecord *precord)
{
ST_dpvt *pST_dpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pST_dpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1;
}
pSTDdev = pST_dpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
/* qData.param.n32Arg0 = pST_dpvt->pchannelConfig->chanIndex; */
qData.param.setValue = precord->val;
/* db processing: phase I */
if(precord->pact == FALSE) {
precord->pact = TRUE;
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pST_dpvt->ind) {
case AO_SET_PEDESTAL:
qData.pFunc = devV792_AO_SET_PEDESTAL;
break;
case AO_TEST_PUT:
qData.pFunc = devV792_AO_TEST_PUT;
break;
case AO_SET_CALB_ITERATION:
qData.pFunc = devV792_AO_SET_CALB_ITERATION;
break;
case AO_SET_CALB_INCREASE_CNT:
qData.pFunc = devV792_AO_SET_CALB_INCREASE_CNT;
break;
case AO_SET_STOP_TIME:
qData.pFunc = devV792_AO_SET_STOP_TIME;
break;
case AO_CHANNEL_MASK:
qData.pFunc = devV792_AO_CHANNEL_MASK;
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*(0)=>(success ) */
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE) {
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s) \n", precord->name, epicsThreadGetNameSelf() );
#endif
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(0)=>(success ) */
}
return -1;
}
static long devBoAdmin_write_bo(boRecord *precord)
{
ST_devAdmin_dpvt *pdevAdmin_dpvt = (ST_devAdmin_dpvt*) precord->dpvt;
ST_ADMIN *pAdminCfg;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pdevAdmin_dpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1;
}
pAdminCfg = pdevAdmin_dpvt->ptaskConfig;
pControlThreadConfig = pAdminCfg->pST_adminCtrlThread;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = (double)precord->val;
/* db processing: phase I */
if(precord->pact == FALSE)
{
precord->pact = TRUE;
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name,
epicsThreadGetNameSelf());
#endif
switch(pdevAdmin_dpvt->ind) {
case BO_AUTO_SAVE:
qData.pFunc = devAdmin_BO_AUTO_SAVE;
break;
case BO_SYS_ARMING:
qData.pFunc = devAdmin_BO_SYS_ARMING;
break;
case BO_SYS_RUN:
qData.pFunc = devAdmin_BO_SYS_RUN;
break;
case BO_DATA_SEND:
qData.pFunc = devAdmin_BO_DATA_SEND;
break;
case BO_SYS_RESET:
qData.pFunc = devAdmin_BO_SYS_RESET;
break;
case BO_BOARD_SETUP:
qData.pFunc = devAdmin_BO_BOARD_SETUP;
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*returns: (-1,0)=>(failure,success)*/
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE)
{
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
precord->pact = FALSE;
precord->udf = FALSE;
switch(pdevAdmin_dpvt->ind) {
case BO_SYS_ARMING:
if( pAdminCfg->StatusAdmin & TASK_ARM_ENABLED ) precord->val = 1;
else precord->val = 0;
break;
case BO_SYS_RUN:
if( pAdminCfg->StatusAdmin & TASK_DAQ_STARTED) precord->val = 1;
else precord->val = 0;
break;
case BO_DATA_SEND:
if( pAdminCfg->StatusAdmin & TASK_DATA_PUT_STORAGE) precord->val = 1;
else precord->val = 0;
break;
default: break;
}
return 0; /*returns: (-1,0)=>(failure,success)*/
}
return -1;
}
static void FPDPthreadFunc(void *param)
{
unsigned long long int start, stop,currentCal;
uint32 shotNu;
int toggle,i;
dmaToggle = 1;
toggle = 1;
drvBufferConfig_Node *pbufferNode = NULL;
drvM6802_taskConfig *ptaskConfig = (drvM6802_taskConfig*) param;
drvM6802_controlThreadConfig *pfpdpThreadConfig;
bufferingThreadQueueData queueData;
while( !ptaskConfig->pfpdpThreadConfig ) epicsThreadSleep(.1);
pfpdpThreadConfig = (drvM6802_controlThreadConfig*) ptaskConfig->pfpdpThreadConfig;
if( drvM6802_init_FPDP() == (-1) ) {
epicsPrintf("\n>>> FPDPthreadFunc : drvM6802_init_FPDP() ... fail\n");
return;
} else
epicsPrintf("\n>>> FPDPthreadFunc : drvM6802_init_FPDP() ... OK\n");
/*
if( !startFpdp() ) {
printf(" can't start FPDP \n");
terminate();
return;
}
*/
i=0;
while(TRUE) {
/* Wait for DMA transfer to complete */
sem_wait (&dmaDoneSemaphore_in);
doCacheInvalidate();
if( dmaToggle ) {
pbufferNode = (drvBufferConfig_Node *)ellFirst(pdrvBufferConfig->pbufferList);
ellDelete(pdrvBufferConfig->pbufferList, &pbufferNode->node);
memcpy( pbufferNode->data, buffer_in, dmaSize/2);
dmaToggle = 0;
toggle = 0;
epicsPrintf("sem_wait_toggle zero :ellCnt %d \n", ellCount(pdrvBufferConfig->pbufferList) );
} else {
memcpy( pbufferNode->data+(dmaSize/2)/sizeof(int), buffer_in+(dmaSize/2)/sizeof(int), dmaSize/2);
pbufferNode->nCnt = ptaskConfig->cnt_DMAcallback;
pbufferNode->nStop = 0;
queueData.pNode = pbufferNode;
epicsMessageQueueSend(pfpdpThreadConfig->threadQueueId, (void*) &queueData, sizeof(bufferingThreadQueueData));
/* epicsPrintf("\n>>> snd ID: %d, DMA cnt: %d\n", pfpdpThreadConfig->threadQueueId, ptaskConfig->cnt_DMAcallback); */
dmaToggle = 1;
toggle = 1;
ptaskConfig->cnt_DMAcallback++;
epicsPrintf("sem_wait_toggle one :ellCnt %d \n", ellCount(pdrvBufferConfig->pbufferList) );
}
/* epicsPrintf("Wait FPDP ?? %d \n", i++); */
if (ptaskConfig->eceCalMode && toggle ==1) {
start = drvM6802_getCurrentUsec();
epicsThreadSleep(1.1);
drvM6802_set_DAQstop(ptaskConfig);
epicsThreadSleep(1.1);
drvM6802_set_DAQclear(ptaskConfig);
epicsThreadSleep(0.1);
dataChannelizationAndSendData(ptaskConfig->shotNumber, 3);
shotNu = ptaskConfig->shotNumber;
ptaskConfig->shotNumber = shotNu + 1;
epicsPrintf("Local Mode - ECE Calibration => shot Number : %d \n",ptaskConfig->shotNumber);
drvM6802_set_DAQready(ptaskConfig);
epicsThreadSleep(0.1);
drvM6802_set_DAQstart(ptaskConfig);
epicsThreadSleep(0.1);
stop = drvM6802_getCurrentUsec();
currentCal = drvM6802_intervalUSec(start, stop);
epicsPrintf("\nECE Calibration Cycle time is %lf msec\n", 1.E-3 * (double)currentCal);
}
} /* while(TRUE) */
terminate();
printf("FPDP >>> Terminated!\n");
return;
}
static long devBoNI6123_write_bo(boRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pSTdpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return 0;
}
pSTDdev = pSTdpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = precord->val;
/* db processing: phase I */
if(precord->pact == FALSE) {
precord->pact = TRUE;
kLog (K_INFO, "db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
switch(pSTdpvt->ind) {
case BO_AUTO_RUN:
qData.pFunc = devNI6123_BO_AUTO_RUN;
break;
case BO_DAQ_STOP:
qData.pFunc = devNI6123_BO_DAQ_STOP;
break;
case BO_TREND_RUN:
qData.pFunc = devNI6123_BO_TREND_RUN;
break;
case BO_CALC_RUN:
qData.pFunc = devNI6123_BO_CALC_RUN;
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*returns: (-1,0)=>(failure,success)*/
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE) {
kLog (K_INFO, "db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf());
precord->pact = FALSE;
precord->udf = FALSE;
switch(pSTdpvt->ind) {
default:
break;
}
return 0; /*returns: (-1,0)=>(failure,success)*/
}
return -1;
}
static long devAoXXX_write_ao(aoRecord *precord)
{
ST_dpvt *pDpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_XXX *pXXX;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pDpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1;
}
pSTDdev = pDpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = precord->val;
pXXX = (ST_XXX*)pSTDdev->pUser;
/* db processing: phase I */
if(precord->pact == FALSE)
{
precord->pact = TRUE;
#if PRINT_DBPRO_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pDpvt->ind)
{
case AO_TEST_1:
qData.pFunc = devAoXXX_AO_TEST_1;
break;
case AO_TEST_2:
qData.pFunc = devAoXXX_AO_TEST_2;
qData.param.n32Arg0 = pDpvt->n32Arg0; /* channel id */
qData.param.n32Arg1 = pDpvt->n32Arg1; /* section id */
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*(0)=>(success ) */
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE)
{
#if PRINT_DBPRO_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pDpvt->ind)
{
case AO_TEST_1:
/*do something */
break;
case AO_TEST_2:
/*do something */
break;
default:
break;
}
precord->pact = FALSE;
precord->udf = FALSE;
return 0; /*(0)=>(success ) */
}
return -1;
}
static long devBoXXX_write_bo(boRecord *precord)
{
ST_dpvt *pDpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pDpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return 0;
}
pSTDdev = pDpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = (double)precord->val;
qData.param.n32Arg0 = pDpvt->n32Arg0;
/* db processing: phase I */
if(precord->pact == FALSE) {
precord->pact = TRUE;
#if PRINT_DBPRO_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
switch(pDpvt->ind) {
case BO_TEST_1:
qData.pFunc = devBoXXX_BO_TEST_1;
break;
case BO_TEST_2:
qData.pFunc = devBoXXX_BO_TEST_2;
break;
default:
break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0;
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE) {
#if PRINT_DBPRO_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf());
#endif
precord->pact = FALSE;
precord->udf = FALSE;
switch(pDpvt->ind) {
case BO_TEST_1:
/*do something */
/*precord->val = 0; */
break;
case BO_TEST_2:
/*do something */
/*precord->val = 0; */
break;
default: break;
}
return 0; /*returns: (-1,0)=>(failure,success)*/
}
return -1;
}
void threadFunc_RTcore_DAQ(void *param)
{
ST_STD_device *pSTDdev = (ST_STD_device*) param;
ST_RTcore *pRTcore;
ST_MASTER *pMaster = NULL;
ST_STD_device *pSTDRMchk = NULL;
ST_RMCHK *pRMCHK;
epicsThreadId pthreadInfo;
ST_User_Buf_node queueData;
ST_buf_node *pbufferNode = NULL;
pMaster = get_master();
if(!pMaster) return;
if( !pSTDdev ) {
printf("ERROR! threadFunc_user_DAQ() has null pointer of STD device.\n");
return;
}
pRTcore = (ST_RTcore *)pSTDdev->pUser;
if( !pRTcore ) {
printf("ERROR! threadFunc_user_DAQ() has null pointer of pRTcore.\n");
return;
}
/* get RFM device ******************************************* */
pSTDRMchk = get_STDev_from_type(STR_DEVICE_TYPE_2);
if( !pSTDRMchk ) {
printf("ERROR! threadFunc_RTcore_DAQ() has null pointer of Dev2.\n");
return;
} else {
printf("target RMchk: %p, eventID:%d\n", pSTDRMchk, pSTDRMchk->ST_DAQThread.threadEventId );
}
pRMCHK = (ST_RMCHK *)pSTDRMchk->pUser;
if( !pRMCHK ) {
printf("ERROR! threadFunc_RTcore_RT() has null pointer of pRMCHK.\n");
return;
}
/*********************************************************** */
#if USE_CPU_AFFINITY_RT
pthreadInfo = epicsThreadGetIdSelf();
/* printf("%s: EPICS ID %p, pthreadID %lu\n", pthreadInfo->name, (void *)pthreadInfo, (unsigned long)pthreadInfo->tid); */
epicsThreadSetCPUAffinity( pthreadInfo, AFFINITY_RTCORE_DAQ);
epicsThreadSetPosixPriority(pthreadInfo, PRIOTY_RTCORE_DAQ, "SCHED_FIFO");
#endif
#if USE_RTCORE_DAQRING
epicsThreadSleep(1.0);
pbufferNode = (ST_buf_node *)ellFirst(pSTDdev->pList_BufferNode);
ellDelete(pSTDdev->pList_BufferNode, &pbufferNode->node);
#endif
while(TRUE) {
epicsEventWait( pSTDdev->ST_DAQThread.threadEventId);
#if USE_RTCORE_DAQ_HIGH
WRITE32(pRTcore->base0 + 0x4, 0x1);
#endif
#if USE_RTCORE_DAQ_LOW
WRITE32(pRTcore->base0 + 0x4, 0x0);
#endif
#if USE_RTCORE_DAQRING
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 0] = pRMCHK->mapBuf[RM_PCS_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 1] = pRMCHK->mapBuf[RM_PF1_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 2] = pRMCHK->mapBuf[RM_PF2_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 3] = pRMCHK->mapBuf[RM_PF3U_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 4] = pRMCHK->mapBuf[RM_PF3L_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 5] = pRMCHK->mapBuf[RM_PF4U_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 6] = pRMCHK->mapBuf[RM_PF4L_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 7] = pRMCHK->mapBuf[RM_PF5U_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 8] = pRMCHK->mapBuf[RM_PF5L_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 9] = pRMCHK->mapBuf[RM_PF6U_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 10] = pRMCHK->mapBuf[RM_PF6L_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 11] = pRMCHK->mapBuf[RM_PF7_CNT/4];
pbufferNode->data[pRTcore->cntDAQ_loop * LOOP_ELM + 12] = pRMCHK->mapBuf[RM_IVC_CNT/4];
// pRTcore->cntDAQ++;
pRTcore->cntDAQ_loop++;
pRTcore->cntAccum += LOOP_ELM;
if( pRTcore->cntDAQ_loop >= LOOP_CNT ) {
queueData.pNode = pbufferNode;
queueData.timeStamp = 0x0;
epicsMessageQueueSend(pSTDdev->ST_RingBufThread.threadQueueId, (void*) &queueData, sizeof(ST_User_Buf_node));
pbufferNode = (ST_buf_node *)ellFirst(pSTDdev->pList_BufferNode);
ellDelete(pSTDdev->pList_BufferNode, &pbufferNode->node);
pRTcore->cntDAQ_loop = 0;
}
#endif
pSTDdev->stdDAQCnt++;
if( pRTcore->useScanIoRequest )
scanIoRequest(pSTDdev->ioScanPvt_userCall);
}
}
int32 CVICALLBACK EveryNCallback6220(TaskHandle taskHandle, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData)
{
int32 error = 0;
char errBuff[2048];
int32 read;
int32 sampsPerChan = daq6220pvt.rate;
int32 buff_size = daq6220pvt.rate*16;
int i, j, ind;
float64 *data;
data = (float64 *)malloc(sizeof(float64)*buff_size);
DAQmxErrChk(DAQmxReadAnalogF64(daq6220pvt.taskHandle, sampsPerChan, 10.0, DAQmx_Val_GroupByChannel, data,
buff_size, &read, NULL));
ind = 0;
daq6220pvt.totalRead += sampsPerChan;
for(i=0; i < 16; i++) {
if(daq6220pvt.mdsput[i]) {
if(daq6220pvt.fp[i] != NULL) {
ind = i*sampsPerChan;
fwrite(&data[ind], sizeof(float64)*sampsPerChan, 1, daq6220pvt.fp[i]);
fflush(daq6220pvt.fp[i]);
if(daq6220pvt.totalRead >= daq6220pvt.sampsPerChan) {
fclose(daq6220pvt.fp[i]);
daq6220pvt.fp[i] = NULL;
epicsPrintf("*** data file save finish... ***\n");
}
}
}
}
if(daq6220pvt.totalRead >= daq6220pvt.sampsPerChan) {
DaqQueueData queueData;
daq6220pvt.totalRead = 0;
SetDaqFinshStop(&daq6220pvt);
daq6220pvt.status = DAQ_STATUS_STOP;
queueData.opcode = OP_CODE_DAQ_MDSPLUS;
epicsMessageQueueSend(daq6220pvt.DaqQueueId, (void *)&queueData, sizeof(DaqQueueData));
}
free(data);
data = NULL;
epicsPrintf("**** NI 6220 File Save Byte : %ld ****\n", buff_size*8);
return 0;
Error:
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
if( daq6220pvt.taskHandle!=0 ) {
DAQmxStopTask(daq6220pvt.taskHandle);
DAQmxClearTask(daq6220pvt.taskHandle);
}
if( DAQmxFailed(error) )
epicsPrintf("DAQmx Error(6220): %s\n",errBuff);
return -1;
}
static long devBoV792Control_write_bo(boRecord *precord)
{
ST_dpvt *pST_dpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_threadCfg *pControlThreadConfig;
ST_threadQueueData qData;
if(!pST_dpvt || precord->udf == TRUE) {
precord->pact = TRUE;
return -1;
}
pSTDdev = pST_dpvt->pSTDdev;
pControlThreadConfig = pSTDdev->pST_stdCtrlThread;
qData.param.pSTDdev = pSTDdev;
qData.param.precord = (struct dbCommon *)precord;
qData.param.setValue = (double)precord->val;
/* db processing: phase I */
if(precord->pact == FALSE) {
precord->pact = TRUE;
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase I %s (%s)\n", precord->name,
epicsThreadGetNameSelf());
#endif
switch(pST_dpvt->ind) {
case BO_READ_ALL_DATA:
qData.pFunc = devV792_BO_READ_ALL_DATA;
break;
case BO_SHOW_STATUS1:
qData.pFunc = devV792_BO_SHOW_STATUS1;
break;
case BO_SHOW_STATUS2:
qData.pFunc = devV792_BO_SHOW_STATUS2;
break;
case BO_DEV_ARMING:
qData.pFunc = devV792_BO_DEV_ARMING;
break;
case BO_DEV_RUN:
qData.pFunc = devV792_BO_DEV_RUN;
break;
case BO_TOGGLE_mean_value:
qData.pFunc = devV792_BO_TOGGLE_mean_value;
break;
case BO_SHOW_MEAN_VALUE: qData.pFunc = devV792_BO_SHOW_MEAN_VALUE; break;
case BO_SHOW_CALIB_INFO: qData.pFunc = devV792_BO_SHOW_CALIB_INFO; break;
case BO_TOGGLE_make_file: qData.pFunc = devV792_BO_TOGGLE_make_file; break;
case BO_TOGGLE_realtime_calc: qData.pFunc = devV792_BO_TOGGLE_realtime_calc; break;
default: break;
}
epicsMessageQueueSend(pControlThreadConfig->threadQueueId,
(void*) &qData,
sizeof(ST_threadQueueData));
return 0; /*returns: (-1,0)=>(failure,success)*/
}
/* db processing: phase II -post processing */
if(precord->pact == TRUE) {
#if PRINT_PHASE_INFO
epicsPrintf("db processing: phase II %s (%s)\n", precord->name, epicsThreadGetNameSelf() );
#endif
precord->pact = FALSE;
precord->udf = FALSE;
#if 0
switch(pST_dpvt->ind) {
case AO_SET_INTERCLK: precord->val = 0; break;
case AO_SET_EXTERCLK: precord->val = 0; break;
case AO_DAQ_START: precord->val = 0; break;
case AO_DAQ_STOP: precord->val = 0; break;
case AO_ADC_START: precord->val = 0; break;
case AO_ADC_STOP: precord->val = 0; break;
case AO_LOCAL_STORAGE: precord->val = 0; break;
case AO_REMOTE_STORAGE: precord->val = 0; break;
case AO_SET_CLEAR_STATUS: precord->val = 0; break;
}
#endif
return 0; /*returns: (-1,0)=>(failure,success)*/
}
return -1;
}
