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; }